home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 2 / AACD 2.iso / AACD / CDROM / SCDPlayer / Sources / scdp.c < prev    next >
C/C++ Source or Header  |  1996-11-09  |  171KB  |  4,049 lines
  1. #include "SCDP.h"
  2. #include "scdplogo.h"
  3.  
  4. /* In v1.5 I got fed of #including in SCDP.h (^: */
  5. #include <rexx/rxslib.h>
  6. #include <rexx/errors.h>
  7. #include <proto/rexxsyslib.h>
  8.  
  9. #include <libraries/asl.h>
  10. #include <proto/asl.h>
  11.  
  12. enum ReturnIDs
  13. {
  14.     ID_Play=1, ID_Pause, ID_Stop, ID_Previous, ID_Next, ID_Rewind, ID_FastForward, ID_Eject,
  15.     ID_Volume,ID_ProgramL,ID_Shuffle,ID_Repeat,
  16.     ID_TrackSelect,ID_ProgramSelect,ID_List,ID_ProgramR,
  17.     ID_Use,ID_Save,ID_RexxSave,ID_Confirm,ID_ChangeActive,ID_PUse,ID_PSave,ID_PRexxSave,ID_PInsert,ID_PAll,
  18.     ID_A1,ID_A2,ID_A3,ID_A4,ID_A5,ID_A6,ID_A7,ID_A8,
  19.     /* For menus */
  20.     MEN_PROJECT,MEN_ABOUT,MEN_ABOUTMUI,MEN_QUIT,MEN_SETTINGS,MEN_MUI,
  21.     MEN_AREXX,MEN_EXECUTE,MEN_A1,MEN_A2,MEN_A3,MEN_A4,MEN_A5,MEN_A6,MEN_A7,MEN_A8
  22.  
  23. };
  24.  
  25. #define min(a,b) (((a)<(b))?(a):(b))
  26.  
  27. #define MyImageButton(image,key,help) ImageObject,MUIA_Background,MUII_ButtonBack, ButtonFrame, MUIA_Weight, 0, MUIA_Image_Spec,"4:PROGDIR:images/" image, /*MUIA_ControlChar, key,*/ MUIA_InputMode,MUIV_InputMode_RelVerify,MUIA_ShortHelp,glstr(help), End
  28. #define MyImageButtonX(image,key,help) ImageObject,MUIA_Background,MUII_ButtonBack, ButtonFrame, MUIA_Weight, 0, MUIA_Image_Spec, image, /*MUIA_ControlChar, key,*/ MUIA_InputMode,MUIV_InputMode_RelVerify,MUIA_ShortHelp,glstr(help), End
  29. #define MyImage(image) ImageObject, MUIA_Weight, 0, MUIA_Image_Spec,"4:PROGDIR:images/" image, End
  30. #define MyImageButton2(image,key,help) ImageObject, MUIA_Background,MUII_ButtonBack, ButtonFrame, MUIA_Weight, 0, MUIA_Image_Spec,"4:PROGDIR:images/" image, /*MUIA_ControlChar, key,*/ MUIA_InputMode,MUIV_InputMode_Toggle,MUIA_ShortHelp,glstr(help), End
  31.  
  32. #define max(a,b) ((a)>(b))?(a):(b)
  33. #define min(a,b) ((a)<(b))?(a):(b)
  34.  
  35. /* Function prototypes */
  36. int DoScsiCmd(UBYTE *data, int datasize, UBYTE *cmd, int cmdsize, UBYTE flags);
  37. void CDEject(void);
  38. void CDLoad(void);
  39. void CDStop(void);
  40. void CDGetPos(BOOL settimer);
  41. void CDSetVolume(int volume);
  42. void CDResume(void);
  43. void CDPause(void);
  44. void CDPlay(int start, int length);
  45. void CDReadContents(void);
  46. void DoShuffle(void);
  47. void DoProgram(void);
  48. void FillList(void);
  49.  
  50. /* Some global vars */
  51. enum status_enum {NODISK,STOPPED,PAUSED,PLAYING} status=NODISK;     /* CD status*/
  52. enum pstatus_enum {NORMAL,PROGRAM,SHUFFLE} pstatus=NORMAL;          /* Program status */
  53. UBYTE track=0;                                                      /* Track being played */
  54. ULONG actualindex=0;/* address in actualtrack */
  55. ULONG totalindex=0; /* address in CD */
  56. UBYTE validTOC=0;   /* 1=We have read a valid TOC, 0=No */
  57. UBYTE *TOCbuf=NULL;      /* Buffer for Table Of Contents */
  58. UBYTE TOClength;    /* Number of tracks */
  59. UBYTE TOCflags[100];/* 0=CDDA, 1=Data */
  60. ULONG TOCaddr[100]; /* Track starts */
  61. char TOCCDID[20];           /* Id string of CD */
  62. char TOCCDtitle[128];       /* Title of actual CD */
  63. char TOCCDartist[128];      /* Artist */
  64.  
  65. UBYTE programmed[101];  /* List of programmed/shuffled tracks */
  66. UBYTE pprog[101];      /* Definitely programmed tracks */
  67. UBYTE pactual;
  68.  
  69. BOOL refresh=FALSE;
  70. BOOL trayout=FALSE;     /* For Eject/Load */
  71. BOOL onevalid=FALSE;     /* Is there at least one CDDA track? */
  72.  
  73. BOOL userstop=TRUE; /* We want CDROM stopped */
  74. UBYTE actuate=0;
  75. UBYTE skip=3;       /* Kludge for waiting for a track's begin */
  76. UBYTE delayedplay=0;    /* Kludge for autoplay */
  77.  
  78. /* Global vars for timing */
  79. struct timerequest *tioreq=NULL;
  80. MSGPORT *tmsgport=NULL;
  81.  
  82. /* Global vars for SCSI control */
  83. IOSTDREQ *ioreq=NULL;
  84. MSGPORT *msgport=NULL;
  85. UBYTE *scsidata=NULL;
  86. SCSICMD *scsicmd=NULL;
  87. UBYTE *scsisense=NULL;
  88.  
  89. UBYTE scsidev[256]="scsi.device";
  90. int scsiid=4;
  91. BOOL volumecontrol=TRUE;
  92. BOOL minvolume=0;
  93.  
  94. /* For the logo */
  95. static struct BitMap logobm=
  96. {
  97.     30,
  98.     30,
  99.     0,
  100.     2,
  101.     PAD,
  102.     (UBYTE *)logoplane0,
  103.     (UBYTE *)logoplane1,
  104.     NULL,NULL,NULL,NULL,NULL,NULL
  105. };
  106.  
  107. const ULONG logocolours[]=
  108. {
  109.     0xc0c0c0c0, 0xc0c0c0c0, 0xc0c0c0c0,
  110.     0x00000000, 0x00000000, 0x00000000,
  111.     0xffffffff, 0xffffffff, 0xffffffff,
  112.     0x46464646, 0x7c7c7c7c, 0xbbbbbbbb
  113. };
  114.  
  115. /* For the menu */
  116. static struct NewMenu menudata[]=
  117. {
  118.     { NM_TITLE, NULL,           0, 0, 0,    (APTR)MEN_PROJECT   },
  119.     { NM_ITEM,  NULL,           0, 0, 0,    (APTR)MEN_ABOUT     },
  120.     { NM_ITEM,  NULL,           0, 0, 0,    (APTR)MEN_ABOUTMUI  },
  121.     { NM_ITEM,  NM_BARLABEL,    0, 0, 0,    (APTR)0             },
  122.     { NM_ITEM,  NULL,           0, 0, 0,    (APTR)MEN_QUIT      },
  123.     { NM_TITLE, NULL,           0, 0, 0,    (APTR)MEN_SETTINGS  },
  124.     { NM_ITEM,  NULL,           0, 0, 0,    (APTR)MEN_MUI       },
  125.     { NM_TITLE, NULL,           0, 0, 0,    (APTR)MEN_AREXX     },
  126.     { NM_ITEM,  NULL,           0, 0, 0,    (APTR)MEN_EXECUTE   },
  127.     { NM_ITEM,  NM_BARLABEL,    0, 0, 0,    (APTR)0             },
  128.     { NM_ITEM, NULL,            0, 0, 0,    (APTR)MEN_A1        },
  129.     { NM_ITEM, NULL,            0, 0, 0,    (APTR)MEN_A2        },
  130.     { NM_ITEM, NULL,            0, 0, 0,    (APTR)MEN_A3        },
  131.     { NM_ITEM, NULL,            0, 0, 0,    (APTR)MEN_A4        },
  132.     { NM_ITEM, NULL,            0, 0, 0,    (APTR)MEN_A5        },
  133.     { NM_ITEM, NULL,            0, 0, 0,    (APTR)MEN_A6        },
  134.     { NM_ITEM, NULL,            0, 0, 0,    (APTR)MEN_A7        },
  135.     { NM_ITEM, NULL,            0, 0, 0,    (APTR)MEN_A8        },
  136.     { NM_END,NULL,0,0,0,(APTR)0 },
  137. };
  138.  
  139. static char *regtitles[3]={NULL,NULL,NULL};
  140.  
  141. static APTR AP_SCDP=NULL;
  142. static APTR WI_SCDP,WI_List,WI_Program;
  143. static APTR TX_Track,TX_TitleTime,TX_CDTime,TX_Artist,TX_Title;
  144. static APTR BT_Play,BT_Pause,BT_Stop,BT_Previous,BT_Next,BT_Rewind,BT_FastForward,BT_Eject,BT_Shuffle,BT_ProgramL,BT_Repeat;
  145. static APTR BT_ProgramR,BT_List;
  146. static APTR SL_Volume;
  147. static APTR ST_Artist,ST_CDTitle,ST_Title,RG_RegTraPro,LV_TrackSelect,LV_ProgramSelect,LV_TitleList,BT_Use,BT_Save,BT_Cancel;
  148. static APTR LV_PList,LI_PList,LV_Program,BT_PUse,BT_PSave,BT_PCancel,BT_PNew,BT_PDelete,BT_PUp,BT_PDown,BT_PTop,BT_PBottom,BT_PAll;
  149. static APTR MN_Menu, WI_AboutMUI=NULL;
  150. static APTR BT_A[8];
  151. /* New for V1.3 */
  152.  
  153. static APTR CH_AutoPlay,CH_AutoProgram,CH_AutoShuffle,CH_AutoRepeat;
  154.  
  155. struct TextFont *getfont(char *name)
  156. {
  157.     char buff[100];
  158.     int i;
  159.     struct TextAttr ta;
  160.  
  161.     i=0;
  162.     while((buff[i]=name[i])!='/' && buff[i]!='\0')
  163.         i++;
  164.  
  165.     if(!buff[i])
  166.         return NULL;
  167.  
  168.     buff[i]='\0';
  169.     strcat(buff,".font");
  170.  
  171.     ta.ta_Name=buff;
  172.     ta.ta_YSize=atoi(name+i+1);
  173.     ta.ta_Style=0;
  174.     ta.ta_Flags=0;
  175.  
  176.     return OpenDiskFont(&ta);
  177. }
  178.  
  179. /* I will try here to program some drag&drop for program window */
  180. /* See DragnDrop.c in MUI examples */
  181. struct ProgramList_Data
  182. {
  183.     LONG dummy;
  184. };
  185.  
  186. ULONG ProgramList_DragQuery(struct IClass *cl, Object *obj, struct MUIP_DragDrop *msg)
  187. {
  188.     if(msg->obj==obj)
  189.         return(DoSuperMethodA(cl,obj,msg));
  190.     else if(msg->obj==(Object *)LI_PList) /* Hard coded source list */
  191.         return(MUIV_DragQuery_Accept);
  192.     else
  193.         return(MUIV_DragQuery_Refuse);
  194. }
  195.  
  196. ULONG ProgramList_DragDrop(struct IClass *cl, Object *obj, struct MUIP_DragDrop *msg)
  197. {
  198.     if(msg->obj==obj)
  199.         return(DoSuperMethodA(cl,obj,msg));
  200.     else
  201.     {
  202.         char *entry;
  203.         LONG dropmark;
  204.  
  205.         DoMethod(msg->obj,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&entry);
  206.  
  207.         get(obj,MUIA_List_DropMark,&dropmark);
  208.         DoMethod(obj,MUIM_List_InsertSingle,entry,dropmark);
  209.  
  210.         get(obj,MUIA_List_InsertPosition,&dropmark);
  211.         set(obj,MUIA_List_Active,dropmark);
  212.         set(msg->obj,MUIA_List_Active,MUIV_List_Active_Off);
  213.  
  214.         return 0;
  215.     }
  216. }
  217.  
  218. SAVEDS ASM ULONG ProgramList_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  219. {
  220.     switch(msg->MethodID)
  221.     {
  222.         case MUIM_DragQuery:    return ProgramList_DragQuery(cl,obj,(APTR)msg);
  223.         case MUIM_DragDrop:     return ProgramList_DragDrop(cl,obj,(APTR)msg);
  224.     }
  225.     return DoSuperMethodA(cl,obj,msg);
  226. }
  227.  
  228. /* New for V1.7 */
  229. /* Handling of keystrokes via custom grroup class */
  230.  
  231. #define TAGBASE_KG (TAG_USER | ( 666 << 16))
  232. #define MUIM_KeyGroup_Timer (TAGBASE_KG | 0x0001)
  233. #define IO_SIGBIT(req)  ((LONG)(((struct IORequest *)req)->io_Message.mn_ReplyPort->mp_SigBit))
  234. #define IO_SIGMASK(req) ((LONG)(1L<<IO_SIGBIT(req)))
  235.  
  236. struct KeyGroup_Data
  237. {
  238.     struct MsgPort *mp;
  239.     struct timerequest *tr;
  240.     
  241.     struct MUI_InputHandlerNode ihn;
  242.     struct MUI_EventHandlerNode ehn;
  243.     
  244.     LONG status;
  245.     LONG number;
  246.     BOOL used_ior;
  247. };
  248.  
  249. ULONG KeyGroup_mNew(struct IClass *cl,Object *obj,Msg msg)
  250. {
  251.     struct KeyGroup_Data *data;
  252.     
  253.     if (!(obj = (Object *)DoSuperMethodA(cl,obj,msg)))
  254.         return(0);    
  255.  
  256.     data=INST_DATA(cl,obj);
  257.     
  258.     if(data->mp=CreateMsgPort())
  259.     {
  260.         if(data->tr=CreateIORequest(data->mp,sizeof(struct timerequest)))
  261.         {
  262.             if(!OpenDevice(TIMERNAME,UNIT_VBLANK,(struct IORequest *)data->tr,0))
  263.             {
  264.                 data->ihn.ihn_Object=obj;
  265.                 data->ihn.ihn_Signals=IO_SIGMASK(data->tr);
  266.                 data->ihn.ihn_Method=MUIM_KeyGroup_Timer;
  267.                 data->ihn.ihn_Flags=0;
  268.                 
  269.                 data->ehn.ehn_Priority=0;
  270.                 data->ehn.ehn_Flags=0;
  271.                 data->ehn.ehn_Events=IDCMP_VANILLAKEY;
  272.                 data->ehn.ehn_Object=obj;
  273.                 data->ehn.ehn_Class=cl;
  274.                 
  275.                 data->status=0;
  276.                 data->number=0;
  277.                 data->used_ior=FALSE;
  278.                 
  279.                 return (ULONG)obj;
  280.             }
  281.         }
  282.     }
  283.     
  284.     CoerceMethod(cl,obj,OM_DISPOSE);
  285.     return 0;
  286. }
  287.  
  288. ULONG KeyGroup_mDispose(struct IClass *cl,Object *obj,Msg msg)
  289. {
  290.     struct KeyGroup_Data *data;
  291.     
  292.     data = INST_DATA(cl,obj);
  293.  
  294.     if (data->tr)
  295.     {
  296.         if(data->tr->tr_node.io_Device)
  297.         {
  298.             CloseDevice((struct IORequest *)data->tr);
  299.         }
  300.         DeleteIORequest(data->tr);
  301.     }
  302.  
  303.     if(data->mp)
  304.         DeleteMsgPort(data->mp);
  305.  
  306.     return(DoSuperMethodA(cl,obj,msg));
  307. }
  308.  
  309. ULONG KeyGroup_mSetup(struct IClass *cl,Object *obj,Msg msg)
  310. {
  311.     struct KeyGroup_Data *data;
  312.        
  313.     data=INST_DATA(cl,obj);
  314.  
  315.     if (!DoSuperMethodA(cl,obj,msg))
  316.         return(FALSE);
  317.  
  318.     DoMethod(_app(obj),MUIM_Application_AddInputHandler,&data->ihn);
  319.     DoMethod(_win(obj),MUIM_Window_AddEventHandler,&data->ehn);
  320.  
  321.     return(TRUE);
  322. }
  323.  
  324. ULONG KeyGroup_mCleanup(struct IClass *cl,Object *obj,Msg msg)
  325. {
  326.     struct KeyGroup_Data *data;
  327.        
  328.     data=INST_DATA(cl,obj);
  329.  
  330.     DoMethod(_win(obj),MUIM_Window_RemEventHandler,&data->ehn);
  331.     DoMethod(_app(obj),MUIM_Application_RemInputHandler,&data->ihn);
  332.  
  333.     if(data->used_ior)
  334.     {
  335.         if (!CheckIO(data->tr)) AbortIO(data->tr);
  336.         WaitIO(data->tr);
  337.     }
  338.  
  339.     return(DoSuperMethodA(cl,obj,msg));
  340. }
  341.  
  342. ULONG KeyGroup_mTimer(struct IClass *cl,Object *obj,Msg msg)
  343. {
  344.     struct KeyGroup_Data *data;
  345.     LONG ent;
  346.     data=INST_DATA(cl,obj);
  347.  
  348.     if (data->used_ior && CheckIO(data->tr))
  349.     {
  350.         WaitIO(data->tr);
  351.         data->used_ior=FALSE;
  352.  
  353.         if(data->status==1)
  354.         {
  355.             data->status=0;
  356.             get(LV_TrackSelect,MUIA_List_Entries,&ent);
  357.             if(data->number<1 || data->number>ent)
  358.             {
  359.                 data->number=0;
  360.             }
  361.             else
  362.             {
  363.                 set(LV_TrackSelect,MUIA_List_Active,data->number-1);
  364.                 DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_TrackSelect);
  365.                 data->number=0;
  366.             }
  367.         }
  368.  
  369.         return(TRUE);
  370.     }
  371.  
  372.     return(FALSE);
  373. }
  374.  
  375. SAVEDS ASM ULONG KeyGroup_mHandleEvent(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) struct MUIP_HandleEvent *msg2)
  376. {
  377.     struct KeyGroup_Data *data;
  378.     struct IntuiMessage *msg;
  379.     LONG ent;
  380.     data=INST_DATA(cl,obj);
  381.     
  382.     if(!(msg2->imsg))
  383.         return 0;
  384.         
  385.     msg=msg2->imsg;
  386.  
  387.     if((msg->Class&(~IDCMP_LONELYMESSAGE))!=IDCMP_VANILLAKEY || msg->Code<'0' || msg->Code>'9')
  388.         return 0;
  389.  
  390.     if(data->status==1)
  391.     {
  392.         data->status=0;
  393.         if(data->used_ior)
  394.         {
  395.             data->used_ior=FALSE;
  396.             if (!CheckIO(data->tr)) AbortIO(data->tr);
  397.             WaitIO(data->tr);
  398.         }
  399.         data->number*=10;
  400.         data->number+=msg->Code-'0';
  401.         
  402.         get(LV_TrackSelect,MUIA_List_Entries,&ent);
  403.         if(data->number<1 || data->number>ent)
  404.         {
  405.             data->number=0;
  406.         }
  407.         else
  408.         {
  409.             set(LV_TrackSelect,MUIA_List_Active,data->number-1);
  410.             DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_TrackSelect);
  411.             data->number=0;
  412.         }
  413.     }
  414.     else
  415.     {
  416.         data->status=1;
  417.         data->number=msg->Code-'0';
  418.         
  419.         data->tr->io_Command=TR_ADDREQUEST;
  420.         data->tr->io_Flags=0;
  421.         data->tr->tr_time.tv_secs=2;
  422.         data->tr->tr_time.tv_micro=0;
  423.         
  424.         data->used_ior=TRUE;
  425.         SendIO((struct IORequest *)data->tr);
  426.     }
  427.  
  428.     return MUI_EventHandlerRC_Eat;
  429. }
  430.  
  431. SAVEDS ASM ULONG KeyGroup_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  432. {
  433.     switch (msg->MethodID)
  434.     {
  435.         case OM_NEW             : return(KeyGroup_mNew    (cl,obj,(APTR)msg));
  436.         case OM_DISPOSE         : return(KeyGroup_mDispose(cl,obj,(APTR)msg));
  437.         case MUIM_Setup         : return(KeyGroup_mSetup  (cl,obj,(APTR)msg));
  438.         case MUIM_Cleanup       : return(KeyGroup_mCleanup(cl,obj,(APTR)msg));
  439.         case MUIM_KeyGroup_Timer: return(KeyGroup_mTimer  (cl,obj,(APTR)msg));
  440.         case MUIM_HandleEvent   : return(KeyGroup_mHandleEvent(cl,obj,(APTR)msg));
  441.     }
  442.  
  443.     return(DoSuperMethodA(cl,obj,msg));
  444. }
  445.  
  446. /* New for V1.4 */
  447. char hotkeys[12][128]=
  448. {
  449.     "control lcommand space",       /* Play */
  450.     "control lcommand z",           /* Pause */
  451.     "control lcommand x",           /* Stop */
  452.     "control lcommand <",           /* Previous */
  453.     "control lcommand >",           /* Next */
  454.     "control lcommand c",           /* Rewind */
  455.     "control lcommand v",           /* Fast forward */
  456.     "control lcommand `",           /* Eject/load */
  457.     "control lcommand p",           /* Program mode */
  458.     "control lcommand s",           /* Shuffle mode */
  459.     "control lcommand r",           /* Repeat mode */
  460.     "control lcommand numericpad enter"        /* CX_POPKEY */
  461. };
  462.  
  463. CxObj *filter[12],*sender[12],*translate[12];
  464.  
  465. SAVEDS ASM void brokerfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) CxMsg *msg)
  466. {
  467.     ULONG msgid,msgtype;
  468.     LONG flag;
  469.  
  470.     msgtype=CxMsgType(msg);
  471.     if(msgtype==CXM_IEVENT)
  472.     {
  473.         msgid=CxMsgID(msg);
  474.         switch(msgid)
  475.         {
  476.             case 0:
  477.                 DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Play);
  478.                 break;
  479.             case 1:
  480.                 DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Pause);
  481.                 break;
  482.             case 2:
  483.                 DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Stop);
  484.                 break;
  485.             case 3:
  486.                 DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Previous);
  487.                 break;
  488.             case 4:
  489.                 DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Next);
  490.                 break;
  491.             case 5:
  492.                 DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Rewind);
  493.                 break;
  494.             case 6:
  495.                 DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_FastForward);
  496.                 break;
  497.             case 7:
  498.                 DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Eject);
  499.                 break;
  500.             case 8:
  501.                 get(BT_ProgramL,MUIA_Selected,&flag);
  502.                 flag^=TRUE;
  503.                 set(BT_ProgramL,MUIA_Selected,flag);
  504.                 break;
  505.             case 9:
  506.                 get(BT_Shuffle,MUIA_Selected,&flag);
  507.                 flag^=TRUE;
  508.                 set(BT_Shuffle,MUIA_Selected,flag);
  509.                 break;
  510.             case 10:
  511.                 get(BT_Repeat,MUIA_Selected,&flag);
  512.                 flag^=TRUE;
  513.                 set(BT_Repeat,MUIA_Selected,flag);
  514.                 break;
  515.             case 11:
  516.                 get(AP_SCDP,MUIA_Application_Iconified,&flag);
  517.                 flag^=TRUE;
  518.                 set(AP_SCDP,MUIA_Application_Iconified,flag);
  519.                 break;
  520.         }
  521.     }
  522. }
  523.  
  524. static const struct Hook brokerhook=
  525. {
  526.     {
  527.         NULL,NULL
  528.     },
  529.     brokerfunction,
  530.     NULL,
  531.     NULL
  532. };
  533.  
  534. int MakeCxObj( CxObj *broker, struct MsgPort *BrokerMP, int nr, char *FiltStr )
  535. {
  536. if (filter[nr] = CxFilter( FiltStr ))
  537.     {
  538.     AttachCxObj(broker, filter[nr]);
  539.     if (sender[nr] = CxSender(BrokerMP, (LONG)nr))
  540.         {
  541.         AttachCxObj(filter[nr], sender[nr] );
  542.         if (translate[nr] = CxTranslate(NULL))
  543.             {
  544.             AttachCxObj(filter[nr], translate[nr]);
  545.             return( CxObjError( filter[nr] ) );
  546.             }
  547.         }
  548.     }
  549. return( 1 );
  550. }
  551.  
  552. void SetUpHotKeys(void)
  553. {
  554.     CxObj *broker;
  555.     struct MsgPort *brokerport;
  556.     int i;
  557.  
  558.     get(AP_SCDP,MUIA_Application_Broker,&broker);
  559.     get(AP_SCDP,MUIA_Application_BrokerPort,&brokerport);
  560.  
  561.     if(!broker || !brokerport)
  562.         return;
  563.  
  564.     for(i=0;i<12;i++)
  565.     {
  566.         MakeCxObj(broker, brokerport, i, hotkeys[i]);
  567.     }
  568. }
  569.  
  570. int popupflag=-1;
  571.  
  572. /* NEW FOR v1.5 ARexx port! */
  573.  
  574. int useraction=0;
  575. BOOL quitting=FALSE;
  576.  
  577. SAVEDS ASM LONG playrawfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  578. {
  579.     LONG a,b;
  580.  
  581.     if(status==NODISK)
  582.         return 5;
  583.     
  584.     useraction=-1;
  585.     
  586.     pstatus=NORMAL;
  587.     set(BT_Shuffle,MUIA_Selected,FALSE);
  588.     set(BT_ProgramL,MUIA_Selected,FALSE);
  589.     set(BT_Repeat,MUIA_Selected,FALSE);
  590.     
  591.     a=*((LONG *)args[0]);
  592.     if(args[1])
  593.     {
  594.         b=*((LONG *)args[1]);
  595.     }
  596.     else
  597.     {
  598.         b=TOCaddr[TOClength];
  599.     }
  600.     
  601.     CDPlay(a,b-a);
  602.     
  603.     actuate=0;
  604.     skip=2;
  605.     
  606.     return 0;
  607. }
  608.  
  609. static const struct Hook playrawhook=
  610. {
  611.     {
  612.         NULL,NULL
  613.     },
  614.     playrawfunction,
  615.     NULL,
  616.     NULL
  617. };
  618.  
  619. SAVEDS ASM LONG playtrackfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  620. {
  621.     LONG a;
  622.  
  623.     if(status==NODISK)
  624.         return 5;
  625.     
  626.     useraction=-1;
  627.     
  628.     pstatus=NORMAL;
  629.     set(BT_Shuffle,MUIA_Selected,FALSE);
  630.     set(BT_ProgramL,MUIA_Selected,FALSE);
  631.     set(BT_Repeat,MUIA_Selected,FALSE);
  632.  
  633.     a=*((LONG *)args[0]);
  634.     
  635.     if(a<1 || a>TOClength || TOCflags[a-1])
  636.         return 5;
  637.     
  638.     CDPlay(TOCaddr[a-1],TOCaddr[a]-TOCaddr[a-1]);
  639.     
  640.     actuate=0;
  641.     skip=2;
  642.     
  643.     return 0;
  644. }
  645.  
  646. static const struct Hook playtrackhook=
  647. {
  648.     {
  649.         NULL,NULL
  650.     },
  651.     playtrackfunction,
  652.     NULL,
  653.     NULL
  654. };
  655.  
  656. SAVEDS ASM LONG playingposfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  657. {
  658.     char buff[20];
  659.  
  660.     if(status==NODISK || status==STOPPED)
  661.     {
  662.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  663.         return 5;
  664.     }
  665.     
  666.     useraction=0;
  667.     
  668.     CDGetPos(FALSE);
  669.     
  670.     sprintf(buff,"%d",totalindex);
  671.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  672.     
  673.     return 0;
  674. }
  675.  
  676. static const struct Hook playingposhook=
  677. {
  678.     {
  679.         NULL,NULL
  680.     },
  681.     playingposfunction,
  682.     NULL,
  683.     NULL
  684. };
  685.  
  686. SAVEDS ASM LONG playingtrackfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  687. {
  688.     char buff[20];
  689.  
  690.     if(status==NODISK || status==STOPPED)
  691.     {
  692.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  693.         return 5;
  694.     }
  695.     
  696.     useraction=0;
  697.     
  698.     CDGetPos(FALSE);
  699.     
  700.     sprintf(buff,"%d",track);
  701.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  702.     
  703.     return 0;
  704. }
  705.  
  706. static const struct Hook playingtrackhook=
  707. {
  708.     {
  709.         NULL,NULL
  710.     },
  711.     playingtrackfunction,
  712.     NULL,
  713.     NULL
  714. };
  715.  
  716. SAVEDS ASM LONG setprogramfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  717. {
  718.     LONG **q;
  719.     int a;
  720.     char *strptr;
  721.  
  722.     if(status==NODISK)
  723.     {
  724.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  725.         return 5;
  726.     }
  727.     
  728.     useraction=0;
  729.     
  730.     set(WI_Program,MUIA_Window_Open,FALSE);
  731.     
  732.     if(pstatus==PROGRAM && status==PLAYING)
  733.     {
  734.         CDStop();
  735.     }   
  736.     
  737.     q=(LONG **)args[0];
  738.     
  739.     if(!q)
  740.     {
  741.         pprog[0]=0;
  742.         if(pstatus==PROGRAM)
  743.         {
  744.             DoProgram();
  745.         }       
  746.  
  747.         DoMethod(LV_ProgramSelect,MUIM_List_Clear);
  748.  
  749.         return 0;
  750.     }
  751.  
  752.     a=0;
  753.     while(q[a])
  754.     {
  755.         if(*(q[a])<1 || *(q[a])>TOClength)
  756.             return 5;
  757.         a++;
  758.     }
  759.     
  760.     a=0;
  761.     while(q[a])
  762.     {
  763.         pprog[a]=*(q[a]);
  764.         a++;
  765.     }
  766.     pprog[a]=0;
  767.     
  768.     if(pstatus==PROGRAM)
  769.     {
  770.         DoProgram();
  771.     }
  772.  
  773.     set(LV_ProgramSelect,MUIA_List_Quiet,TRUE);
  774.     DoMethod(LV_ProgramSelect,MUIM_List_Clear);
  775.     a=0;
  776.     while(pprog[a])
  777.     {
  778.         DoMethod(LV_TrackSelect,MUIM_List_GetEntry,pprog[a]-1,&strptr);
  779.         DoMethod(LV_ProgramSelect,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  780.         a++;
  781.     }
  782.     set(LV_ProgramSelect,MUIA_List_Quiet,FALSE);
  783.     
  784.     return 0;
  785. }
  786.  
  787. static const struct Hook setprogramhook=
  788. {
  789.     {
  790.         NULL,NULL
  791.     },
  792.     setprogramfunction,
  793.     NULL,
  794.     NULL
  795. };
  796.  
  797. SAVEDS ASM LONG programfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  798. {
  799.     int a;
  800.     char buff[10];
  801.  
  802.     if(status==NODISK)
  803.     {
  804.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  805.         return 5;
  806.     }
  807.     
  808.     useraction=-1;
  809.     
  810.     if(args[0])
  811.     {
  812.         a=*((LONG *)args[0]);
  813.         if(a)
  814.             a=1;
  815.         set(BT_ProgramL,MUIA_Selected,a);
  816.     }
  817.     
  818.     get(BT_ProgramL,MUIA_Selected,&a);
  819.     
  820.     sprintf(buff,"%d",a);
  821.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  822.     
  823.     return 0;
  824. }
  825.  
  826. static const struct Hook programhook=
  827. {
  828.     {
  829.         NULL,NULL
  830.     },
  831.     programfunction,
  832.     NULL,
  833.     NULL
  834. };
  835.  
  836. SAVEDS ASM LONG shufflefunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  837. {
  838.     int a;
  839.     char buff[10];
  840.  
  841.     if(status==NODISK)
  842.     {
  843.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  844.         return 5;
  845.     }
  846.     
  847.     useraction=-1;
  848.     
  849.     if(args[0])
  850.     {
  851.         a=*((LONG *)args[0]);
  852.         if(a)
  853.             a=1;
  854.         set(BT_Shuffle,MUIA_Selected,a);
  855.     }
  856.     
  857.     get(BT_Shuffle,MUIA_Selected,&a);
  858.     
  859.     sprintf(buff,"%d",a);
  860.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  861.     
  862.     return 0;
  863. }
  864.  
  865. static const struct Hook shufflehook=
  866. {
  867.     {
  868.         NULL,NULL
  869.     },
  870.     shufflefunction,
  871.     NULL,
  872.     NULL
  873. };
  874.  
  875. SAVEDS ASM LONG repeatfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  876. {
  877.     int a;
  878.     char buff[10];
  879.  
  880.     if(status==NODISK)
  881.     {
  882.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  883.         return 5;
  884.     }
  885.     
  886.     useraction=0;
  887.     
  888.     if(args[0])
  889.     {
  890.         a=*((LONG *)args[0]);
  891.         if(a)
  892.             a=1;
  893.         set(BT_Repeat,MUIA_Selected,a);
  894.     }
  895.     
  896.     get(BT_Repeat,MUIA_Selected,&a);
  897.     
  898.     sprintf(buff,"%d",a);
  899.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  900.     
  901.     return 0;
  902. }
  903.  
  904. static const struct Hook repeathook=
  905. {
  906.     {
  907.         NULL,NULL
  908.     },
  909.     repeatfunction,
  910.     NULL,
  911.     NULL
  912. };
  913.  
  914. SAVEDS ASM LONG autoprogramfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  915. {
  916.     int a;
  917.     char buff[10];
  918.  
  919.     if(status==NODISK)
  920.     {
  921.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  922.         return 5;
  923.     }
  924.     
  925.     useraction=0;
  926.     
  927.     if(args[0])
  928.     {
  929.         a=*((LONG *)args[0]);
  930.         if(a)
  931.             a=1;
  932.         set(CH_AutoProgram,MUIA_Selected,a);
  933.     }
  934.     
  935.     get(CH_AutoProgram,MUIA_Selected,&a);
  936.     
  937.     sprintf(buff,"%d",a);
  938.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  939.     
  940.     return 0;
  941. }
  942.  
  943. static const struct Hook autoprogramhook=
  944. {
  945.     {
  946.         NULL,NULL
  947.     },
  948.     autoprogramfunction,
  949.     NULL,
  950.     NULL
  951. };
  952.  
  953. SAVEDS ASM LONG autoshufflefunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  954. {
  955.     int a;
  956.     char buff[10];
  957.  
  958.     if(status==NODISK)
  959.     {
  960.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  961.         return 5;
  962.     }
  963.     
  964.     useraction=0;
  965.     
  966.     if(args[0])
  967.     {
  968.         a=*((LONG *)args[0]);
  969.         if(a)
  970.             a=1;
  971.         set(CH_AutoShuffle,MUIA_Selected,a);
  972.     }
  973.     
  974.     get(CH_AutoShuffle,MUIA_Selected,&a);
  975.     
  976.     sprintf(buff,"%d",a);
  977.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  978.     
  979.     return 0;
  980. }
  981.  
  982. static const struct Hook autoshufflehook=
  983. {
  984.     {
  985.         NULL,NULL
  986.     },
  987.     autoshufflefunction,
  988.     NULL,
  989.     NULL
  990. };
  991.  
  992. SAVEDS ASM LONG autorepeatfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  993. {
  994.     int a;
  995.     char buff[10];
  996.  
  997.     if(status==NODISK)
  998.     {
  999.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1000.         return 5;
  1001.     }
  1002.     
  1003.     useraction=0;
  1004.     
  1005.     if(args[0])
  1006.     {
  1007.         a=*((LONG *)args[0]);
  1008.         if(a)
  1009.             a=1;
  1010.         set(CH_AutoRepeat,MUIA_Selected,a);
  1011.     }
  1012.     
  1013.     get(CH_AutoRepeat,MUIA_Selected,&a);
  1014.     
  1015.     sprintf(buff,"%d",a);
  1016.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  1017.     
  1018.     return 0;
  1019. }
  1020.  
  1021. static const struct Hook autorepeathook=
  1022. {
  1023.     {
  1024.         NULL,NULL
  1025.     },
  1026.     autorepeatfunction,
  1027.     NULL,
  1028.     NULL
  1029. };
  1030.  
  1031. SAVEDS ASM LONG autoplayfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1032. {
  1033.     int a;
  1034.     char buff[10];
  1035.  
  1036.     if(status==NODISK)
  1037.     {
  1038.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1039.         return 5;
  1040.     }
  1041.     
  1042.     useraction=0;
  1043.     
  1044.     if(args[0])
  1045.     {
  1046.         a=*((LONG *)args[0]);
  1047.         if(a)
  1048.             a=1;
  1049.         set(CH_AutoPlay,MUIA_Selected,a);
  1050.     }
  1051.     
  1052.     get(CH_AutoPlay,MUIA_Selected,&a);
  1053.     
  1054.     sprintf(buff,"%d",a);
  1055.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  1056.     
  1057.     return 0;
  1058. }
  1059.  
  1060. static const struct Hook autoplayhook=
  1061. {
  1062.     {
  1063.         NULL,NULL
  1064.     },
  1065.     autoplayfunction,
  1066.     NULL,
  1067.     NULL
  1068. };
  1069.  
  1070. SAVEDS ASM LONG programmedtracksfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1071. {
  1072.     int a;
  1073.     char buff[10];
  1074.     
  1075.     if(status==NODISK)
  1076.     {
  1077.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1078.         return 5;
  1079.     }
  1080.     
  1081.     useraction=0;
  1082.     
  1083.     a=0;
  1084.     while(pprog[a])
  1085.         a++;
  1086.     
  1087.     sprintf(buff,"%d",a);
  1088.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  1089.     
  1090.     return 0;
  1091. }
  1092.  
  1093. static const struct Hook programmedtrackshook=
  1094. {
  1095.     {
  1096.         NULL,NULL
  1097.     },
  1098.     programmedtracksfunction,
  1099.     NULL,
  1100.     NULL
  1101. };
  1102.  
  1103. SAVEDS ASM LONG programmedtrackfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1104. {
  1105.     int a,b;
  1106.     char buff[10];
  1107.     char *strptr;
  1108.     
  1109.     if(!args[0])
  1110.     {
  1111.         if(pstatus!=PROGRAM || status!=PLAYING)
  1112.         {
  1113.             set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1114.             return 5;
  1115.         }
  1116.         sprintf(buff,"%d",pactual);
  1117.         set(AP_SCDP,MUIA_Application_RexxString,buff);
  1118.     
  1119.         useraction=0;
  1120.     
  1121.         return 0;
  1122.     }
  1123.     
  1124.     if(status==NODISK)
  1125.     {
  1126.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1127.         return 5;
  1128.     }
  1129.     
  1130.     set(WI_Program,MUIA_Window_Open,FALSE);
  1131.     
  1132.     b=*((LONG *)args[0]);
  1133.     a=0;
  1134.     while(pprog[a])
  1135.         a++;
  1136.     
  1137.     if(b<1 || b>a)
  1138.         return 5;
  1139.     
  1140.     useraction=0;
  1141.         
  1142.     if(args[1])
  1143.     {
  1144.         a=*((LONG *)args[1]);
  1145.         
  1146.         pprog[b-1]=a;
  1147.         if(pstatus==PROGRAM && status==PLAYING)
  1148.         {
  1149.             CDStop();
  1150.         }
  1151.         if(pstatus==PROGRAM)
  1152.         {
  1153.             DoProgram();
  1154.         }       
  1155.     }
  1156.     
  1157.     sprintf(buff,"%d",pprog[b]);
  1158.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  1159.  
  1160.     set(LV_ProgramSelect,MUIA_List_Quiet,TRUE);
  1161.     DoMethod(LV_ProgramSelect,MUIM_List_Clear);
  1162.     a=0;
  1163.     while(pprog[a])
  1164.     {
  1165.         DoMethod(LV_TrackSelect,MUIM_List_GetEntry,pprog[a]-1,&strptr);
  1166.         DoMethod(LV_ProgramSelect,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  1167.         a++;
  1168.     }
  1169.     set(LV_ProgramSelect,MUIA_List_Quiet,FALSE);
  1170.     
  1171.     return 0;
  1172. }
  1173.  
  1174. static const struct Hook programmedtrackhook=
  1175. {
  1176.     {
  1177.         NULL,NULL
  1178.     },
  1179.     programmedtrackfunction,
  1180.     NULL,
  1181.     NULL
  1182. };
  1183.  
  1184. SAVEDS ASM LONG addprogrammedtrackfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1185. {
  1186.     int a,b;
  1187.     char *strptr;
  1188.  
  1189.     if(status==NODISK)
  1190.     {
  1191.         return 5;
  1192.     }
  1193.     
  1194.     useraction=0;
  1195.     
  1196.     set(WI_Program,MUIA_Window_Open,FALSE);
  1197.     
  1198.     b=*((LONG *)args[0]);
  1199.     a=0;
  1200.     while(pprog[a])
  1201.         a++;
  1202.     
  1203.     pprog[a++]=b;
  1204.     pprog[a]=0;
  1205.     if(pstatus==PROGRAM && status==PLAYING)
  1206.     {
  1207.         CDStop();
  1208.     }
  1209.     if(pstatus==PROGRAM)
  1210.     {
  1211.         DoProgram();
  1212.     }       
  1213.  
  1214.     set(LV_ProgramSelect,MUIA_List_Quiet,TRUE);
  1215.     DoMethod(LV_ProgramSelect,MUIM_List_Clear);
  1216.     a=0;
  1217.     while(pprog[a])
  1218.     {
  1219.         DoMethod(LV_TrackSelect,MUIM_List_GetEntry,pprog[a]-1,&strptr);
  1220.         DoMethod(LV_ProgramSelect,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  1221.         a++;
  1222.     }
  1223.     set(LV_ProgramSelect,MUIA_List_Quiet,FALSE);
  1224.     
  1225.     return 0;
  1226. }
  1227.  
  1228. static const struct Hook addprogrammedtrackhook=
  1229. {
  1230.     {
  1231.         NULL,NULL
  1232.     },
  1233.     addprogrammedtrackfunction,
  1234.     NULL,
  1235.     NULL
  1236. };
  1237.  
  1238. SAVEDS ASM LONG cdtitlefunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1239. {
  1240.     if(status==NODISK)
  1241.         return 5;
  1242.     
  1243.     useraction=0;
  1244.     
  1245.     if(args[0])
  1246.     {
  1247.         set(WI_List,MUIA_Window_Open,FALSE);
  1248.         strcpy(TOCCDtitle,(char *)args[0]);
  1249.         refresh=TRUE;
  1250.     }   
  1251.  
  1252.     set(AP_SCDP,MUIA_Application_RexxString,TOCCDtitle);
  1253.  
  1254.     return 0;
  1255. }
  1256.  
  1257. static const struct Hook cdtitlehook=
  1258. {
  1259.     {
  1260.         NULL,NULL
  1261.     },
  1262.     cdtitlefunction,
  1263.     NULL,
  1264.     NULL
  1265. };
  1266.  
  1267. SAVEDS ASM LONG cdartistfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1268. {
  1269.     if(status==NODISK)
  1270.         return 5;
  1271.     
  1272.     useraction=0;
  1273.     
  1274.     if(args[0])
  1275.     {
  1276.         set(WI_List,MUIA_Window_Open,FALSE);
  1277.         strcpy(TOCCDartist,(char *)args[0]);
  1278.         refresh=TRUE;
  1279.     }   
  1280.  
  1281.     set(AP_SCDP,MUIA_Application_RexxString,TOCCDartist);
  1282.  
  1283.     return 0;
  1284. }
  1285.  
  1286. static const struct Hook cdartisthook=
  1287. {
  1288.     {
  1289.         NULL,NULL
  1290.     },
  1291.     cdartistfunction,
  1292.     NULL,
  1293.     NULL
  1294. };
  1295.  
  1296. SAVEDS ASM LONG cdtracksfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1297. {
  1298.     char buff[8];
  1299.     
  1300.     if(status==NODISK)
  1301.     {
  1302.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1303.         return 5;
  1304.     }
  1305.     
  1306.     useraction=0;
  1307.     
  1308.     sprintf(buff,"%d",TOClength);
  1309.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  1310.  
  1311.     return 0;
  1312. }
  1313.  
  1314. static const struct Hook cdtrackshook=
  1315. {
  1316.     {
  1317.         NULL,NULL
  1318.     },
  1319.     cdtracksfunction,
  1320.     NULL,
  1321.     NULL
  1322. };
  1323.  
  1324. SAVEDS ASM LONG tracknamefunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1325. {
  1326.     char *strptr;
  1327.     char buff[256];
  1328.     int a;
  1329.     
  1330.     if(status==NODISK)
  1331.     {
  1332.         return 5;
  1333.     }
  1334.     
  1335.     a=*((LONG *)args[0]);
  1336.     
  1337.     if(a<1 || a>TOClength)
  1338.         return 5;
  1339.     
  1340.     useraction=0;
  1341.     
  1342.     if(args[1])
  1343.     {
  1344.         DoMethod(LV_TrackSelect,MUIM_List_Remove,a-1);
  1345.         sprintf(buff,"%02d: %s",a,(char *)args[1]);
  1346.         DoMethod(LV_TrackSelect,MUIM_List_InsertSingle,buff,a-1);
  1347.         refresh=TRUE;
  1348.     }   
  1349.     
  1350.     DoMethod(LV_TrackSelect,MUIM_List_GetEntry,a-1,&strptr);
  1351.     set(AP_SCDP,MUIA_Application_RexxString,strptr+4);
  1352.  
  1353.     return 0;
  1354. }
  1355.  
  1356. static const struct Hook tracknamehook=
  1357. {
  1358.     {
  1359.         NULL,NULL
  1360.     },
  1361.     tracknamefunction,
  1362.     NULL,
  1363.     NULL
  1364. };
  1365.  
  1366. SAVEDS ASM LONG trackstartfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1367. {
  1368.     char buff[16];
  1369.     int a;
  1370.     
  1371.     if(status==NODISK)
  1372.     {
  1373.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1374.         return 5;
  1375.     }
  1376.     
  1377.     a=*((LONG *)args[0]);
  1378.     
  1379.     if(a<1 || a>TOClength)
  1380.     {
  1381.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1382.         return 5;
  1383.     }
  1384.     
  1385.     useraction=0;
  1386.     
  1387.     sprintf(buff,"%d",TOCaddr[a-1]);
  1388.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  1389.  
  1390.     return 0;
  1391. }
  1392.  
  1393. static const struct Hook trackstarthook=
  1394. {
  1395.     {
  1396.         NULL,NULL
  1397.     },
  1398.     trackstartfunction,
  1399.     NULL,
  1400.     NULL
  1401. };
  1402.  
  1403. SAVEDS ASM LONG trackendfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1404. {
  1405.     char buff[16];
  1406.     int a;
  1407.     
  1408.     if(status==NODISK)
  1409.     {
  1410.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1411.         return 5;
  1412.     }
  1413.     
  1414.     a=*((LONG *)args[0]);
  1415.     
  1416.     if(a<1 || a>TOClength)
  1417.     {
  1418.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1419.         return 5;
  1420.     }
  1421.     
  1422.     useraction=0;
  1423.     
  1424.     sprintf(buff,"%d",TOCaddr[a]);
  1425.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  1426.  
  1427.     return 0;
  1428. }
  1429.  
  1430. static const struct Hook trackendhook=
  1431. {
  1432.     {
  1433.         NULL,NULL
  1434.     },
  1435.     trackendfunction,
  1436.     NULL,
  1437.     NULL
  1438. };
  1439.  
  1440. SAVEDS ASM LONG isdatatrackfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1441. {
  1442.     char buff[16];
  1443.     int a;
  1444.     
  1445.     if(status==NODISK)
  1446.     {
  1447.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1448.         return 5;
  1449.     }
  1450.     
  1451.     a=*((LONG *)args[0]);
  1452.     
  1453.     if(a<1 || a>TOClength)
  1454.     {
  1455.         set(AP_SCDP,MUIA_Application_RexxString,"-1");
  1456.         return 5;
  1457.     }
  1458.     
  1459.     useraction=0;
  1460.     
  1461.     sprintf(buff,"%d",TOCflags[a-1]);
  1462.     set(AP_SCDP,MUIA_Application_RexxString,buff);
  1463.  
  1464.     return 0;
  1465. }
  1466.  
  1467. static const struct Hook isdatatrackhook=
  1468. {
  1469.     {
  1470.         NULL,NULL
  1471.     },
  1472.     isdatatrackfunction,
  1473.     NULL,
  1474.     NULL
  1475. };
  1476.  
  1477. SAVEDS ASM LONG playfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1478. {
  1479.     if(status==NODISK)
  1480.         return 5;
  1481.         
  1482.     useraction=-1;
  1483.         
  1484.     DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Play);
  1485.     return 0;
  1486. }
  1487.  
  1488. static const struct Hook playhook=
  1489. {
  1490.     {
  1491.         NULL,NULL
  1492.     },
  1493.     playfunction,
  1494.     NULL,
  1495.     NULL
  1496. };
  1497.  
  1498. SAVEDS ASM LONG stopfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1499. {
  1500.     if(status==NODISK)
  1501.         return 5;
  1502.         
  1503.     useraction=-1;
  1504.         
  1505.     DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Stop);
  1506.     return 0;
  1507. }
  1508.  
  1509. static const struct Hook stophook=
  1510. {
  1511.     {
  1512.         NULL,NULL
  1513.     },
  1514.     stopfunction,
  1515.     NULL,
  1516.     NULL
  1517. };
  1518.  
  1519. SAVEDS ASM LONG pausefunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1520. {
  1521.     if(status==NODISK)
  1522.         return 5;
  1523.     
  1524.     useraction=-1;
  1525.         
  1526.     DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Pause);
  1527.     return 0;
  1528. }
  1529.  
  1530. static const struct Hook pausehook=
  1531. {
  1532.     {
  1533.         NULL,NULL
  1534.     },
  1535.     pausefunction,
  1536.     NULL,
  1537.     NULL
  1538. };
  1539.  
  1540. SAVEDS ASM LONG previousfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1541. {
  1542.     if(status==NODISK)
  1543.         return 5;
  1544.     
  1545.     useraction=-1;
  1546.     
  1547.     DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Previous);
  1548.     return 0;
  1549. }
  1550.  
  1551. static const struct Hook previoushook=
  1552. {
  1553.     {
  1554.         NULL,NULL
  1555.     },
  1556.     previousfunction,
  1557.     NULL,
  1558.     NULL
  1559. };
  1560.  
  1561. SAVEDS ASM LONG nextfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1562. {
  1563.     if(status==NODISK)
  1564.         return 5;
  1565.     
  1566.     useraction=-1;
  1567.         
  1568.     DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Next);
  1569.     return 0;
  1570. }
  1571.  
  1572. static const struct Hook nexthook=
  1573. {
  1574.     {
  1575.         NULL,NULL
  1576.     },
  1577.     nextfunction,
  1578.     NULL,
  1579.     NULL
  1580. };
  1581.  
  1582. SAVEDS ASM LONG rewindfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1583. {
  1584.     if(status==NODISK)
  1585.         return 5;
  1586.     
  1587.     useraction=-1;
  1588.         
  1589.     DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Rewind);
  1590.     return 0;
  1591. }
  1592.  
  1593. static const struct Hook rewindhook=
  1594. {
  1595.     {
  1596.         NULL,NULL
  1597.     },
  1598.     rewindfunction,
  1599.     NULL,
  1600.     NULL
  1601. };
  1602.  
  1603. SAVEDS ASM LONG fastforwardfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1604. {
  1605.     if(status==NODISK)
  1606.         return 5;
  1607.     
  1608.     useraction=-1;
  1609.         
  1610.     DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_FastForward);
  1611.     return 0;
  1612. }
  1613.  
  1614. static const struct Hook fastforwardhook=
  1615. {
  1616.     {
  1617.         NULL,NULL
  1618.     },
  1619.     fastforwardfunction,
  1620.     NULL,
  1621.     NULL
  1622. };
  1623.  
  1624. SAVEDS ASM LONG ejectfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1625. {
  1626.     CDEject();
  1627.     
  1628.     useraction=0;
  1629.     
  1630.     return 0;
  1631. }
  1632.  
  1633. static const struct Hook ejecthook=
  1634. {
  1635.     {
  1636.         NULL,NULL
  1637.     },
  1638.     ejectfunction,
  1639.     NULL,
  1640.     NULL
  1641. };
  1642.  
  1643. SAVEDS ASM LONG loadfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1644. {
  1645.     if(status!=NODISK)
  1646.         return 5;
  1647.         
  1648.     useraction=0;
  1649.         
  1650.     CDLoad();
  1651.     return 0;
  1652. }
  1653.  
  1654. static const struct Hook loadhook=
  1655. {
  1656.     {
  1657.         NULL,NULL
  1658.     },
  1659.     loadfunction,
  1660.     NULL,
  1661.     NULL
  1662. };
  1663.  
  1664. SAVEDS ASM LONG volumefunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1665. {
  1666.     char buff[16];
  1667.     int a;
  1668.     
  1669.     if(args[0])
  1670.     {
  1671.         a=*((LONG *)args[0]);
  1672.         set(SL_Volume,MUIA_Slider_Level,a);
  1673.     }
  1674.     
  1675.     get(SL_Volume,MUIA_Slider_Level,&a);
  1676.     sprintf(buff,"%d",a);
  1677.     set(AP_SCDP,MUIA_Application_RexxString,buff);  
  1678.     return 0;
  1679. }
  1680.  
  1681. static const struct Hook volumehook=
  1682. {
  1683.     {
  1684.         NULL,NULL
  1685.     },
  1686.     volumefunction,
  1687.     NULL,
  1688.     NULL
  1689. };
  1690.  
  1691. SAVEDS ASM LONG idfilenamefunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1692. {
  1693.     if(status==NODISK)
  1694.         return 5;
  1695.     
  1696.     useraction=0;
  1697.     
  1698.     set(AP_SCDP,MUIA_Application_RexxString,TOCCDID);  
  1699.     return 0;
  1700. }
  1701.  
  1702. static const struct Hook idfilenamehook=
  1703. {
  1704.     {
  1705.         NULL,NULL
  1706.     },
  1707.     idfilenamefunction,
  1708.     NULL,
  1709.     NULL
  1710. };
  1711.  
  1712. SAVEDS ASM LONG diskspathfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1713. {
  1714.     if(status==NODISK)
  1715.         return 5;
  1716.     
  1717.     useraction=0;
  1718.     
  1719.     set(AP_SCDP,MUIA_Application_RexxString,diskspath);  
  1720.     return 0;
  1721. }
  1722.  
  1723. static const struct Hook diskspathhook=
  1724. {
  1725.     {
  1726.         NULL,NULL
  1727.     },
  1728.     diskspathfunction,
  1729.     NULL,
  1730.     NULL
  1731. };
  1732.  
  1733. SAVEDS ASM LONG closelistfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1734. {
  1735.     useraction=0;
  1736.     
  1737.     set(WI_List,MUIA_Window_Open,FALSE);  
  1738.     return 0;
  1739. }
  1740.  
  1741. static const struct Hook closelisthook=
  1742. {
  1743.     {
  1744.         NULL,NULL
  1745.     },
  1746.     closelistfunction,
  1747.     NULL,
  1748.     NULL
  1749. };
  1750.  
  1751. SAVEDS ASM LONG closeprogramfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1752. {
  1753.     useraction=0;
  1754.     
  1755.     set(WI_Program,MUIA_Window_Open,FALSE);  
  1756.     return 0;
  1757. }
  1758.  
  1759. static const struct Hook closeprogramhook=
  1760. {
  1761.     {
  1762.         NULL,NULL
  1763.     },
  1764.     closeprogramfunction,
  1765.     NULL,
  1766.     NULL
  1767. };
  1768.  
  1769. SAVEDS ASM LONG statusfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1770. {
  1771.     useraction=0;
  1772.     
  1773.     switch(status)
  1774.     {
  1775.         case NODISK:
  1776.             set(AP_SCDP,MUIA_Application_RexxString,"NODISK");
  1777.             break;  
  1778.         case STOPPED:
  1779.             set(AP_SCDP,MUIA_Application_RexxString,"STOPPED");
  1780.             break;  
  1781.         case PLAYING:
  1782.             set(AP_SCDP,MUIA_Application_RexxString,"PLAYING");
  1783.             break;  
  1784.         case PAUSED:
  1785.             set(AP_SCDP,MUIA_Application_RexxString,"PAUSED");
  1786.             break;  
  1787.     }
  1788.     return 0;
  1789. }
  1790.  
  1791. static const struct Hook statushook=
  1792. {
  1793.     {
  1794.         NULL,NULL
  1795.     },
  1796.     statusfunction,
  1797.     NULL,
  1798.     NULL
  1799. };
  1800.  
  1801. SAVEDS ASM LONG useractionfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1802. {
  1803.     if(quitting)
  1804.     {
  1805.         set(AP_SCDP,MUIA_Application_RexxString,"2");
  1806.         return 0;
  1807.     }
  1808.     
  1809.     switch(useraction)
  1810.     {
  1811.         case -1:
  1812.         case 0:
  1813.             set(AP_SCDP,MUIA_Application_RexxString,"0");
  1814.             break;  
  1815.         case 1:
  1816.             set(AP_SCDP,MUIA_Application_RexxString,"1");
  1817.             break;  
  1818.     }
  1819.     
  1820.     useraction=0;
  1821.     
  1822.     return 0;
  1823. }
  1824.  
  1825. static const struct Hook useractionhook=
  1826. {
  1827.     {
  1828.         NULL,NULL
  1829.     },
  1830.     useractionfunction,
  1831.     NULL,
  1832.     NULL
  1833. };
  1834.  
  1835. SAVEDS ASM LONG sleepfunction(REG(a0) struct Hook *hook, REG(a2) APTR app, REG(a1) LONG *args)
  1836. {
  1837.     int a=0;
  1838.     
  1839.     useraction=0;
  1840.     
  1841.     a=*((LONG *)args[0]);
  1842.     if(a)
  1843.         a=1;
  1844.     set(AP_SCDP,MUIA_Application_Sleep,a);
  1845.     
  1846.     return 0;
  1847. }
  1848.  
  1849. static const struct Hook sleephook=
  1850. {
  1851.     {
  1852.         NULL,NULL
  1853.     },
  1854.     sleepfunction,
  1855.     NULL,
  1856.     NULL
  1857. };
  1858.  
  1859. struct MUI_Command rxcmds[]=
  1860. {                                                                                           /*  Done  */
  1861.     {"PLAYRAW",     "STARTADDRESS/N/A,ENDADDRESS/N",        2,      &playrawhook},              /**/
  1862.     {"PLAYTRACK",   "TRACK/N/A",                            1,      &playtrackhook},            /**/
  1863.     {"PLAYINGPOS",  NULL,                                   0,      &playingposhook},           /**/
  1864.     {"PLAYINGTRACK",  NULL,                                 0,      &playingtrackhook},         /**/
  1865.     {"PROGRAM",     "NEW/N",                                1,      &programhook},              /**/
  1866.     {"SHUFFLE",     "NEW/N",                                1,      &shufflehook},              /**/
  1867.     {"REPEAT",      "NEW/N",                                1,      &repeathook},               /**/
  1868.     {"AUTOPROGRAM", "NEW/N",                                1,      &autoprogramhook},          /**/
  1869.     {"AUTOSHUFFLE", "NEW/N",                                1,      &autoshufflehook},          /**/
  1870.     {"AUTOREPEAT",  "NEW/N",                                1,      &autorepeathook},           /**/
  1871.     {"AUTOPLAY",    "NEW/N",                                1,      &autoplayhook},             /**/
  1872.     {"SETPROGRAM",  "TRACKNUMBERS/N/M",                     1,      &setprogramhook},           /**/
  1873.     {"PROGRAMMEDTRACKS",    NULL,                           0,      &programmedtrackshook},     /**/
  1874.     {"PROGRAMMEDTRACK", "NUMBER/N,NEW/N",                   2,      &programmedtrackhook},      /**/
  1875.     {"ADDPROGRAMMEDTRACK",  "NUMBER/N/A",                   1,      &addprogrammedtrackhook},   /**/
  1876.     {"SAVEPROGRAM", MC_TEMPLATE_ID,                         ID_PRexxSave,   NULL},              /**/
  1877.     {"CDTITLE",     "TITLE",                                1,      &cdtitlehook},              /**/
  1878.     {"CDARTIST",    "ARTIST",                               1,      &cdartisthook},             /**/
  1879.     {"TRACKS",      NULL,                                   0,      &cdtrackshook},             /**/
  1880.     {"TRACKNAME",   "NUMBER/N/A,NAME",                      2,      &tracknamehook},            /**/
  1881.     {"TRACKSTART",  "NUMBER/N/A",                           1,      &trackstarthook},           /**/
  1882.     {"TRACKEND",    "NUMBER/N/A",                           1,      &trackendhook},             /**/
  1883.     {"ISDATATRACK", "NUMBER/N/A",                           1,      &isdatatrackhook},          /**/
  1884.     {"SAVECDDATA",  MC_TEMPLATE_ID,                         ID_RexxSave,    NULL},              /**/
  1885.     {"PLAY",        NULL,                                   0,      &playhook},                 /**/
  1886.     {"STOP",        NULL,                                   0,      &stophook},                 /**/
  1887.     {"PAUSE",       NULL,                                   0,      &pausehook},                /**/
  1888.     {"PREVIOUS",    NULL,                                   0,      &previoushook},             /**/
  1889.     {"NEXT",        NULL,                                   0,      &nexthook},                 /**/
  1890.     {"REWIND",      NULL,                                   0,      &rewindhook},               /**/
  1891.     {"FASTFORWARD", NULL,                                   0,      &fastforwardhook},          /**/
  1892.     {"EJECT",       NULL,                                   0,      &ejecthook},                /**/
  1893.     {"LOAD",        NULL,                                   0,      &loadhook},                 /**/
  1894.     {"VOLUME",      "LEVEL/N",                              1,      &volumehook},               /**/
  1895.     {"IDFILENAME",  NULL,                                   0,      &idfilenamehook},           /**/
  1896.     {"DISKSPATH",   NULL,                                   0,      &diskspathhook},            /**/
  1897.     {"OPENLIST",    MC_TEMPLATE_ID,                         ID_List,    NULL},                  /**/
  1898.     {"CLOSELIST",   NULL,                                   0,      &closelisthook},            /**/
  1899.     {"OPENPROGRAM", MC_TEMPLATE_ID,                         ID_ProgramR,    NULL},              /**/
  1900.     {"CLOSEPROGRAM",    NULL,                               0,      &closeprogramhook},         /**/
  1901.     {"STATUS",      NULL,                                   0,      &statushook},               /**/
  1902.     {"USERACTION",  NULL,                                   0,      &useractionhook},           /**/
  1903.     {"SLEEP", "NEW/N/A",                                    1,      &sleephook},                /**/
  1904.     {NULL,NULL,NULL,NULL}
  1905. };
  1906.  
  1907. /* Some more vars for ARexx support */
  1908. BOOL rexxok=FALSE;
  1909. char scriptonstart[256]="";
  1910. char scriptonquit[256]="";
  1911. char scriptoninsert[256]="";
  1912. char menuscripts[8][256]={"","","","","","","",""};
  1913. char buttonscripts[8][256]={"","","","","","","",""};
  1914. char buttonimages[8][256]={"","","","","","","",""};
  1915. int menuscriptsno=0;
  1916. int buttonscriptsno=0;
  1917. struct MsgPort *rxmp=NULL;
  1918. int rxmsgs=0;
  1919.  
  1920. int StartARexx(void)
  1921. {   
  1922.     if((rxmp=CreateMsgPort()) && (FindPort("REXX")))
  1923.     {
  1924.         rexxok=TRUE;
  1925.     }
  1926.     return rexxok;
  1927. }
  1928.  
  1929. void LaunchARexxScript(char *command)
  1930. {
  1931.     struct RexxMsg *rxmsg=NULL;
  1932.     struct MsgPort *rp=NULL;
  1933.     char *strptr;
  1934.  
  1935.     BOOL ok=FALSE;
  1936.     
  1937.     if(!rexxok || quitting)
  1938.         return;
  1939.  
  1940.     if(rxmsgs)
  1941.     {
  1942.         while(rxmsg=GetMsg(rxmp))
  1943.         {
  1944.             ClearRexxMsg(rxmsg,1);
  1945.             DeleteRexxMsg(rxmsg);
  1946.             rxmsgs--;
  1947.         }
  1948.     }
  1949.     
  1950.     get(AP_SCDP,MUIA_Application_Base,&strptr);
  1951.     
  1952.     if(rxmsg=CreateRexxMsg(rxmp,"scdp",strptr))
  1953.     {
  1954.         if (rxmsg->rm_Args[0]=CreateArgstring(command,strlen(command)))
  1955.         {
  1956.             rxmsg->rm_Action=RXCOMM|RXFF_NOIO;
  1957.             
  1958.             Forbid();
  1959.             if(rp=FindPort("REXX"))
  1960.             {
  1961.                 PutMsg(rp,(struct Message *) rxmsg);
  1962.                     
  1963.                 Permit();
  1964.                 
  1965.                 rxmsgs++;
  1966.                 ok=TRUE;
  1967.             }   
  1968.             else
  1969.                 Permit();
  1970.                 
  1971.             if(!ok)
  1972.                 ClearRexxMsg(rxmsg,1);
  1973.         }
  1974.         if(!ok)
  1975.             DeleteRexxMsg(rxmsg);
  1976.     }   
  1977. }
  1978.  
  1979. void EndARexx(void)
  1980. {
  1981.     struct RexxMsg *rxmsg=NULL;
  1982.     
  1983.     if(rexxok)
  1984.     {
  1985.         while(rxmsgs)
  1986.         {
  1987.             WaitPort(rxmp);
  1988.             while(rxmsg=GetMsg(rxmp))
  1989.             {
  1990.                 ClearRexxMsg(rxmsg,1);
  1991.                 DeleteRexxMsg(rxmsg);
  1992.                 rxmsgs--;
  1993.             }
  1994.         }
  1995.         DeleteMsgPort(rxmp);
  1996.     }
  1997. }
  1998.  
  1999. /* Main program at last */
  2000. int main(int argc, char *argv[])
  2001. {
  2002.     char *errorstr=NULL;
  2003.     int i,vamos,a,b;
  2004.     ULONG signals;
  2005.     char buff[256];
  2006.     UBYTE *strptr=NULL;
  2007.     struct DiskObject *mydo;
  2008.     FILE *f;
  2009.     BPTR l;
  2010.  
  2011.     if(stacksize()<STACKSIZE)
  2012.         fail(NULL,glstr(MSG_FailStack));
  2013.  
  2014.     if(argc==0)
  2015.     {
  2016.         argc=_WBArgc;
  2017.         argv=_WBArgv;
  2018.     }
  2019.  
  2020.     i=strlen(argv[0]);
  2021.     while(argv[0][i]!='/' && argv[0][i]!=':' && i)
  2022.         i--;
  2023.  
  2024.     if(argv[0][i]=='/' || argv[0][i]==':')
  2025.         sprintf(buff,"PROGDIR:%s",argv[0]+i+1);
  2026.     else
  2027.         sprintf(buff,"PROGDIR:%s",argv[0]);
  2028.  
  2029.     init();
  2030.  
  2031.     mydo=GetDiskObject(buff);
  2032.  
  2033.     for(a=1;a<argc;a++)
  2034.     {
  2035.         if(!strncmp(argv[a],"DEVICE=",7))
  2036.             strcpy(scsidev,argv[a]+7);
  2037.         if(!strncmp(argv[a],"UNIT=",5))
  2038.             scsiid=atoi(argv[a]+5);
  2039.         if(!strcmp(argv[a],"NOVOLUME"))
  2040.             volumecontrol=FALSE;
  2041.         if(!strncmp(argv[a],"MINVOLUME=",10))
  2042.             minvolume=atoi(argv[a]+10);
  2043.         if(!strcmp(argv[a],"CUSTOMFONTS"))
  2044.             customfonts=TRUE;
  2045.         if(!strncmp(argv[a],"NORMALFONT=",11))
  2046.             normalname=argv[a]+11;
  2047.         if(!strncmp(argv[a],"TINYFONT=",9))
  2048.             tinyname=argv[a]+9;
  2049.         if(!strncmp(argv[a],"FIXEDFONT=",10))
  2050.             fixedname=argv[a]+10;
  2051.         if(!strncmp(argv[a],"LISTFONT=",9))
  2052.             listname=argv[a]+9;
  2053.         if(!strncmp(argv[a],"TITLEFONT=",10))
  2054.             titlename=argv[a]+10;
  2055.  
  2056.         if(!strncmp(argv[a],"CX_POPUP=",9))
  2057.         {
  2058.             if(!strcmp("NO",argv[a]+9))
  2059.                 popupflag=0;
  2060.             if(!strcmp("YES",argv[a]+9))
  2061.                 popupflag=1;
  2062.         }
  2063.         if(!strncmp(argv[a],"CX_POPKEY=",10))
  2064.             strcpy(hotkeys[11],argv[a]+10);
  2065.         if(!strncmp(argv[a],"PLAY_KEY=",9))
  2066.             strcpy(hotkeys[0],argv[a]+9);
  2067.         if(!strncmp(argv[a],"PAUSE_KEY=",10))
  2068.             strcpy(hotkeys[1],argv[a]+10);
  2069.         if(!strncmp(argv[a],"STOP_KEY=",9))
  2070.             strcpy(hotkeys[2],argv[a]+9);
  2071.         if(!strncmp(argv[a],"PREVIOUS_KEY=",13))
  2072.             strcpy(hotkeys[3],argv[a]+13);
  2073.         if(!strncmp(argv[a],"NEXT_KEY=",9))
  2074.             strcpy(hotkeys[4],argv[a]+9);
  2075.         if(!strncmp(argv[a],"REWIND_KEY=",11))
  2076.             strcpy(hotkeys[5],argv[a]+11);
  2077.         if(!strncmp(argv[a],"FASTFORWARD_KEY=",16))
  2078.             strcpy(hotkeys[6],argv[a]+16);
  2079.         if(!strncmp(argv[a],"EJECT_KEY=",10))
  2080.             strcpy(hotkeys[7],argv[a]+10);
  2081.         if(!strncmp(argv[a],"PROGRAM_KEY=",12))
  2082.             strcpy(hotkeys[8],argv[a]+12);
  2083.         if(!strncmp(argv[a],"SHUFFLE_KEY=",12))
  2084.             strcpy(hotkeys[9],argv[a]+12);
  2085.         if(!strncmp(argv[a],"REPEAT_KEY=",11))
  2086.             strcpy(hotkeys[10],argv[a]+11);
  2087.             
  2088.         if(!strncmp(argv[a],"DISKSPATH=",10))
  2089.             strcpy(diskspath,argv[a]+10);
  2090.  
  2091.         if(!strncmp(argv[a],"SCRIPTONSTART=",14))
  2092.             strcpy(scriptonstart,argv[a]+14);
  2093.         if(!strncmp(argv[a],"SCRIPTONQUIT=",13))
  2094.             strcpy(scriptonquit,argv[a]+13);
  2095.         if(!strncmp(argv[a],"SCRIPTONINSERT=",15))
  2096.             strcpy(scriptoninsert,argv[a]+15);
  2097.             
  2098.         if(!strncmp(argv[a],"MENUSCRIPT=",11) && menuscriptsno<8)
  2099.             strcpy(menuscripts[menuscriptsno++],argv[a]+11);
  2100.         
  2101.         if(!strncmp(argv[a],"BUTTONSCRIPT=",13) && buttonscriptsno<8)
  2102.         {
  2103.             char *p;
  2104.             int i=0;
  2105.             
  2106.             p=argv[a]+13;
  2107.             
  2108.             while(*p!='|' && *p!='\0')
  2109.             {
  2110.                 buttonscripts[buttonscriptsno][i++]=*p++;
  2111.             }
  2112.             if((*p++)=='|')
  2113.             {
  2114.                 buttonscripts[buttonscriptsno][i]='\0';
  2115.                 strcpy(buttonimages[buttonscriptsno],"4:PROGDIR:Images/");
  2116.                 strcat(buttonimages[buttonscriptsno],p);
  2117.                 buttonscriptsno++;
  2118.             }
  2119.         }
  2120.     }
  2121.  
  2122.     if(l=Lock(diskspath,ACCESS_READ))
  2123.     {
  2124.         NameFromLock(l,diskspath,512);
  2125.         UnLock(l);
  2126.     }
  2127.  
  2128.     if(diskspath[0] && diskspath[strlen(diskspath)-1]!='/' && diskspath[strlen(diskspath)-1]!=':')
  2129.     {
  2130.         strcat(diskspath,"/");
  2131.     }
  2132.  
  2133.     if(customfonts)
  2134.     {
  2135.         normalfont=getfont(normalname);
  2136.         tinyfont=getfont(tinyname);
  2137.         fixedfont=getfont(fixedname);
  2138.         listfont=getfont(listname);
  2139.         titlefont=getfont(titlename);
  2140.  
  2141.         if(!normalfont || !tinyfont || !fixedfont || !listfont || !titlefont)
  2142.             fail(NULL,glstr(MSG_FailNoFont));
  2143.     }
  2144.  
  2145.     if(msgport=CreateMsgPort())
  2146.     {
  2147.         if(ioreq=CreateIORequest(msgport,sizeof(IOSTDREQ)))
  2148.         {
  2149.             if(!(OpenDevice(scsidev,scsiid,(struct IORequest *)ioreq,0)))
  2150.             {
  2151.                 if(scsicmd=AllocMem(sizeof(SCSICMD), MEMF_CHIP|MEMF_CLEAR|MEMF_PUBLIC))
  2152.                 {
  2153.                     if(scsisense=AllocMem(SENSE_LEN, MEMF_CHIP|MEMF_CLEAR|MEMF_PUBLIC))
  2154.                     {
  2155.                         if(tmsgport=CreateMsgPort())
  2156.                         {
  2157.                             if(tioreq=CreateIORequest(tmsgport,sizeof(struct timerequest)))
  2158.                             {
  2159.                                 if(!(OpenDevice(TIMERNAME,UNIT_VBLANK,(struct IORequest *)tioreq,0)))
  2160.                                 {
  2161.                                     if(scsidata=AllocMem(MAX_DATA_LEN,MEMF_CHIP|MEMF_CLEAR|MEMF_PUBLIC))
  2162.                                     {
  2163.                                         if(TOCbuf=AllocMem(MAX_TOC_LEN,MEMF_CHIP|MEMF_PUBLIC))
  2164.                                         {
  2165.                                             programmed[0]=0;
  2166.  
  2167.                                             menudata[0].nm_Label=glstr(MSG_MenuProject);
  2168.                                             menudata[1].nm_Label=glstr(MSG_MenuAbout);
  2169.                                             menudata[1].nm_CommKey=glstr(MSG_MenuAboutKey);
  2170.                                             menudata[2].nm_Label=glstr(MSG_MenuAboutMUI);
  2171.                                             menudata[4].nm_Label=glstr(MSG_MenuQuit);
  2172.                                             menudata[4].nm_CommKey=glstr(MSG_MenuQuitKey);
  2173.                                             menudata[5].nm_Label=glstr(MSG_MenuSettings);
  2174.                                             menudata[6].nm_Label=glstr(MSG_MenuMUI);
  2175.                                             menudata[7].nm_Label=glstr(MSG_ARexx);
  2176.                                             menudata[8].nm_Label=glstr(MSG_Execute);
  2177.                                             for(a=0;a<menuscriptsno;a++)
  2178.                                             {
  2179.                                                 char *p,*q;
  2180.                                                 p=q=menuscripts[a];
  2181.                                                 while(*q)
  2182.                                                 {
  2183.                                                     if(*q=='/' || *q==':')
  2184.                                                         p=q+1;
  2185.                                                     q++;
  2186.                                                 }
  2187.                                                 menudata[10+a].nm_Label=p;
  2188.                                             }
  2189.                                             menudata[a+10].nm_Type=NM_END;
  2190.                                             menudata[a+10].nm_Label=NULL;
  2191.                                             menudata[a+10].nm_Flags=0;
  2192.                                             menudata[a+10].nm_UserData=NULL;
  2193.                                             
  2194.                                             regtitles[0]=glstr(MSG_TitleList);
  2195.                                             regtitles[1]=glstr(MSG_ProgramList);
  2196.  
  2197.                                             AP_SCDP=NULL;
  2198.  
  2199.                                             CL_ProgramList=MUI_CreateCustomClass(NULL,MUIC_List,NULL,sizeof(struct ProgramList_Data),ProgramList_Dispatcher);
  2200.                                             CL_KeyGroup=MUI_CreateCustomClass(NULL,MUIC_Group,NULL,sizeof(struct KeyGroup_Data),KeyGroup_Dispatcher);
  2201.                                             
  2202.                                             if(CL_ProgramList && CL_KeyGroup)
  2203.                                             {
  2204.                                                 AP_SCDP = ApplicationObject,
  2205.                                                     MUIA_Application_Title,         "SCDPlayer",
  2206.                                                     MUIA_Application_Version,       "$VER: SCDPlayer " VERSION " (" __DATE__ " " __TIME__ ")",
  2207.                                                     MUIA_Application_Copyright,     "Copyright ©1996, Juan J. García de Soria",
  2208.                                                     MUIA_Application_Author,        "Juan J. García de Soria",
  2209.                                                     MUIA_Application_Description,   glstr(MSG_SCDPDescription),
  2210.                                                     MUIA_Application_Base,          "SCDP",
  2211.                                                     MUIA_Application_DiskObject,    mydo,
  2212.                                                     MUIA_Application_Menustrip,MN_Menu=MUI_MakeObject(MUIO_MenustripNM,menudata,0),
  2213.                                                     MUIA_Application_SingleTask,TRUE,
  2214.                                                     MUIA_Application_BrokerHook,&brokerhook,
  2215.                                                     MUIA_Application_Commands,rxcmds,
  2216.                                                     SubWindow,
  2217.                                                         WI_SCDP=WindowObject,
  2218.                                                         MUIA_Window_Title, "SCDPlayer " VERSION,
  2219.                                                         MUIA_Window_ID,MAKE_ID('S','C','D','P'),
  2220.                                                         WindowContents,HGroup,
  2221.                                                             MUIA_Background,MUII_WindowBack,
  2222.                                                             MUIA_Font,(customfonts)?(ULONG)normalfont:MUIV_Font_Normal,
  2223.                                                             Child,VGroup,   /* Lado izquierdo de la ventana */
  2224.                                                                 MUIA_Background,MUII_WindowBack,
  2225.                                                                 MUIA_Weight,1,
  2226.                                                                 Child,VGroup,
  2227.                                                                     MUIA_VertDisappear,1,
  2228.                                                                     MUIA_Background,MUII_TextBack,
  2229.                                                                     MUIA_Weight,70,
  2230.                                                                     TextFrame,
  2231.                                                                     Child,VSpace(0),
  2232.                                                                     Child,HGroup,
  2233.                                                                         Child,HSpace(0),
  2234.                                                                         Child,BitmapObject,
  2235.                                                                             MUIA_FixWidth,232,
  2236.                                                                             MUIA_FixHeight,30,
  2237.                                                                             MUIA_Bitmap_Bitmap,&logobm,
  2238.                                                                             MUIA_Bitmap_Transparent,0,
  2239.                                                                             MUIA_Bitmap_Width,232,
  2240.                                                                             MUIA_Bitmap_Height,30,
  2241.                                                                             MUIA_Bitmap_SourceColors,logocolours,
  2242.                                                                             End,
  2243.                                                                         Child,HSpace(0),
  2244.                                                                         End,
  2245.                                                                     Child,VSpace(0),
  2246.                                                                     End,
  2247.                                                                 Child,NewObject(CL_KeyGroup->mcc_Class,NULL,         /* VGroup,*/   /* Zona de estado */
  2248.                                                                     MUIA_VertDisappear,2,
  2249.                                                                     MUIA_Background,MUII_TextBack,
  2250.                                                                     GroupFrame,
  2251.                                                                     MUIA_ShortHelp,glstr(MSG_HelpInfo),
  2252.                                                                     Child,VSpace(0),
  2253.                                                                     Child,HGroup,   /* Los tres indicadores */
  2254.                                                                         Child,VGroup,   /* Nº de pista */
  2255.                                                                             MUIA_Weight,0,
  2256.                                                                             Child,TextObject,
  2257.                                                                                 MUIA_Font,(customfonts)?(ULONG)tinyfont:MUIV_Font_Tiny,
  2258.                                                                                 MUIA_Text_Contents,glstr(MSG_Track),
  2259.                                                                                 MUIA_Text_PreParse,"\33l",
  2260.                                                                                 End,
  2261.                                                                             Child,TX_Track=TextObject,
  2262.                                                                                 MUIA_Font,(customfonts)?(ULONG)fixedfont:MUIV_Font_Fixed,
  2263.                                                                                 MUIA_Text_Contents,"--",
  2264.                                                                                 MUIA_Text_PreParse,"\33l",
  2265.                                                                                 End,
  2266.                                                                             End,
  2267.                                                                         Child,HSpace(0),
  2268.                                                                         Child,VGroup,   /* Posición en pista actual */
  2269.                                                                             MUIA_Weight,0,
  2270.                                                                             Child,TextObject,
  2271.                                                                                 MUIA_Font,(customfonts)?(ULONG)tinyfont:MUIV_Font_Tiny,
  2272.                                                                                 MUIA_Text_Contents,glstr(MSG_TitleTime),
  2273.                                                                                 MUIA_Text_PreParse,"\33l",
  2274.                                                                                 End,
  2275.                                                                             Child,TX_TitleTime=TextObject,
  2276.                                                                                 MUIA_Font,(customfonts)?(ULONG)fixedfont:MUIV_Font_Fixed,
  2277.                                                                                 MUIA_Text_Contents,"--:--/--:--",
  2278.                                                                                 MUIA_Text_PreParse,"\33l",
  2279.                                                                                 End,
  2280.                                                                             End,
  2281.                                                                         Child,HSpace(0),
  2282.                                                                         Child,VGroup,   /* Posición en todo el CD */
  2283.                                                                             MUIA_Weight,0,
  2284.                                                                             Child,TextObject,
  2285.                                                                                 MUIA_Font,(customfonts)?(ULONG)tinyfont:MUIV_Font_Tiny,
  2286.                                                                                 MUIA_Text_Contents,glstr(MSG_CDTime),
  2287.                                                                                 MUIA_Text_PreParse,"\33l",
  2288.                                                                                 End,
  2289.                                                                             Child,TX_CDTime=TextObject,
  2290.                                                                                 MUIA_Font,(customfonts)?(ULONG)fixedfont:MUIV_Font_Fixed,
  2291.                                                                                 MUIA_Text_Contents,"--:--/--:--",
  2292.                                                                                 MUIA_Text_PreParse,"\33l",
  2293.                                                                                 End,
  2294.                                                                             End,
  2295.                                                                         End,
  2296.                                                                     Child,TX_Artist=TextObject,
  2297.                                                                         MUIA_Font,(customfonts)?(ULONG)normalfont:MUIV_Font_Normal,
  2298.                                                                         MUIA_Text_SetMin,FALSE,
  2299.                                                                         MUIA_Text_Contents,glstr(MSG_NoDisc),
  2300.                                                                         MUIA_Text_PreParse,"\33l",
  2301.                                                                         End,
  2302.                                                                     Child,TX_Title=TextObject,
  2303.                                                                         MUIA_Text_SetMin,FALSE,
  2304.                                                                         MUIA_Font,(customfonts)?(ULONG)normalfont:MUIV_Font_Normal,
  2305.                                                                         MUIA_Text_Contents,"",
  2306.                                                                         MUIA_Text_PreParse,"\33l",
  2307.                                                                         End,
  2308.                                                                     Child,VSpace(0),
  2309.                                                                     TAG_DONE), /*End,*/
  2310.                                                                 Child,HGroup,
  2311.                                                                     MUIA_Background,MUII_GroupBack,
  2312.                                                                     GroupFrame,
  2313.                                                                     Child,HSpace(0),
  2314.                                                                     Child,VGroup,
  2315.                                                                         Child,VSpace(0),
  2316.                                                                         Child,HGroup,
  2317.                                                                             MUIA_Weight,0,
  2318.                                                                             Child,BT_Play=MyImageButton("Play",' ',MSG_HelpPlay),
  2319.                                                                             Child,BT_Pause=MyImageButton("Pause",'.',MSG_HelpPause),
  2320.                                                                             Child,BT_Stop=MyImageButton("Stop",'s',MSG_HelpStop),
  2321.                                                                             Child,BT_Previous=MyImageButton("Previous",'p',MSG_HelpPrevious),
  2322.                                                                             Child,BT_Next=MyImageButton("Next",'n',MSG_HelpNext),
  2323.                                                                             Child,BT_Rewind=MyImageButton("Rewind",'r',MSG_HelpRewind),
  2324.                                                                             Child,BT_FastForward=MyImageButton("FastForward",'f',MSG_HelpFastForward),
  2325.                                                                             Child,BT_Eject=MyImageButton("Eject",'e',MSG_HelpEject),
  2326.                                                                             End,
  2327.                                                                         Child,HGroup,
  2328.                                                                             Child,BT_A[0]=(buttonscriptsno>0)?MyImageButtonX(buttonimages[0],'!',MSG_HelpRexxButton):HSpace(0),
  2329.                                                                             Child,BT_A[1]=(buttonscriptsno>1)?MyImageButtonX(buttonimages[1],'@',MSG_HelpRexxButton):HSpace(0),
  2330.                                                                             Child,BT_A[2]=(buttonscriptsno>2)?MyImageButtonX(buttonimages[2],'#',MSG_HelpRexxButton):HSpace(0),
  2331.                                                                             Child,BT_A[3]=(buttonscriptsno>3)?MyImageButtonX(buttonimages[3],'$',MSG_HelpRexxButton):HSpace(0),
  2332.                                                                             Child,BT_A[4]=(buttonscriptsno>4)?MyImageButtonX(buttonimages[4],'%',MSG_HelpRexxButton):HSpace(0),
  2333.                                                                             Child,BT_A[5]=(buttonscriptsno>5)?MyImageButtonX(buttonimages[5],'^',MSG_HelpRexxButton):HSpace(0),
  2334.                                                                             Child,BT_A[6]=(buttonscriptsno>6)?MyImageButtonX(buttonimages[6],'&',MSG_HelpRexxButton):HSpace(0),
  2335.                                                                             Child,BT_A[7]=(buttonscriptsno>7)?MyImageButtonX(buttonimages[7],'*',MSG_HelpRexxButton):HSpace(0),
  2336.                                                                             End,
  2337.                                                                         Child,HGroup,
  2338.                                                                             Child,HGroup,
  2339.                                                                                 MUIA_ShowMe,volumecontrol,
  2340.                                                                                 Child,MyImage("VolumeLow"),
  2341.                                                                                 Child,SL_Volume=SliderObject,
  2342.                                                                                     MUIA_ShortHelp,glstr(MSG_HelpVolume),
  2343.                                                                                     MUIA_Slider_Min,0,
  2344.                                                                                     MUIA_Slider_Max,255,
  2345.                                                                                     MUIA_Slider_Level,16,
  2346.                                                                                     MUIA_Slider_Quiet,TRUE,
  2347.                                                                                     End,
  2348.                                                                                 Child,MyImage("VolumeHigh"),
  2349.                                                                                 End,
  2350.                                                                             Child,BT_ProgramL=MyImageButton2("Program",'o',MSG_HelpProgramL),
  2351.                                                                             Child,BT_Shuffle=MyImageButton2("Shuffle",'q',MSG_HelpShuffle),
  2352.                                                                             Child,BT_Repeat=MyImageButton2("Repeat",'a',MSG_HelpRepeat),
  2353.                                                                             End,
  2354.                                                                         Child,VSpace(0),
  2355.                                                                         End,
  2356.                                                                     Child,HSpace(0),
  2357.                                                                     End,
  2358.                                                                 End,
  2359.                                                             Child,BalanceObject,
  2360.                                                                 MUIA_Weight,1,
  2361.                                                                 MUIA_HorizDisappear,1,
  2362.                                                                 End,
  2363.                                                             Child,VGroup,   /* Lado derecho de la ventana */
  2364.                                                                 MUIA_HorizDisappear,1,
  2365.                                                                 MUIA_Weight,99,
  2366.                                                                 MUIA_Background,MUII_GroupBack,
  2367.                                                                 GroupFrame,
  2368.                                                                 Child,RG_RegTraPro=RegisterGroup(regtitles),
  2369.                                                                     MUIA_Background,MUII_RegisterBack,
  2370.                                                                     Child,LV_TrackSelect=ListviewObject,
  2371.                                                                         MUIA_ShortHelp,glstr(MSG_HelpTrackSelect),
  2372.                                                                         MUIA_Listview_List,ListObject,
  2373.                                                                             ReadListFrame,
  2374.                                                                             MUIA_Font,(customfonts)?(ULONG)listfont:MUIV_Font_List,
  2375.                                                                             MUIA_List_ConstructHook,MUIV_List_ConstructHook_String,
  2376.                                                                             MUIA_List_DestructHook,MUIV_List_DestructHook_String,
  2377.                                                                             MUIA_Background,MUII_ListBack,
  2378.                                                                             End,
  2379.                                                                         End,
  2380.                                                                     Child,LV_ProgramSelect=ListviewObject,
  2381.                                                                         MUIA_ShortHelp,glstr(MSG_HelpTrackSelect),
  2382.                                                                         MUIA_Listview_List,ListObject,
  2383.                                                                             ReadListFrame,
  2384.                                                                             MUIA_Font,(customfonts)?(ULONG)listfont:MUIV_Font_List,
  2385.                                                                             MUIA_List_ConstructHook,MUIV_List_ConstructHook_String,
  2386.                                                                             MUIA_List_DestructHook,MUIV_List_DestructHook_String,
  2387.                                                                             MUIA_Background,MUII_ListBack,
  2388.                                                                             End,
  2389.                                                                         End,
  2390.                                                                     End,
  2391.                                                                 Child,HGroup,
  2392.                                                                     Child,BT_List=SimpleButton(glstr(MSG_ListButton)),
  2393.                                                                     Child,BT_ProgramR=SimpleButton(glstr(MSG_ProgramButton)),
  2394.                                                                     End,
  2395.                                                                 End,
  2396.                                                             End,
  2397.                                                         End,
  2398.                                                     SubWindow,
  2399.                                                         WI_List=WindowObject,
  2400.                                                         MUIA_Window_Title, glstr(MSG_CDInformation),
  2401.                                                         MUIA_Window_ID,MAKE_ID('L','I','S','T'),
  2402.                                                         WindowContents,VGroup,
  2403.                                                             MUIA_Background,MUII_WindowBack,
  2404.                                                             MUIA_Font,(customfonts)?(ULONG)normalfont:MUIV_Font_Normal,
  2405.                                                             Child,ColGroup(2),
  2406.                                                                 Child,Label2(glstr(MSG_Artist)),
  2407.                                                                 Child,ST_Artist=StringObject,
  2408.                                                                     StringFrame,
  2409.                                                                     MUIA_ShortHelp,glstr(MSG_HelpArtist),
  2410.                                                                     MUIA_String_MaxLen,127,
  2411.                                                                     End,
  2412.                                                                 Child,Label2(glstr(MSG_CDTitle)),
  2413.                                                                 Child,ST_CDTitle=StringObject,
  2414.                                                                     StringFrame,
  2415.                                                                     MUIA_ShortHelp,glstr(MSG_HelpCDTitle),
  2416.                                                                     MUIA_String_MaxLen,127,
  2417.                                                                     End,
  2418.                                                                 End,
  2419.                                                             Child,TextObject,
  2420.                                                                 MUIA_Font,(customfonts)?(ULONG)titlefont:MUIV_Font_Title,
  2421.                                                                 MUIA_Text_Contents,glstr(MSG_TitleList),
  2422.                                                                 MUIA_Text_PreParse,"\33c",
  2423.                                                                 End,
  2424.                                                             Child,LV_TitleList=ListviewObject,
  2425.                                                                 MUIA_Listview_List,ListObject,
  2426.                                                                     MUIA_Font,(customfonts)?(ULONG)listfont:MUIV_Font_List,
  2427.                                                                     MUIA_ShortHelp,glstr(MSG_HelpTitles),
  2428.                                                                     InputListFrame,
  2429.                                                                     MUIA_List_ConstructHook,MUIV_List_ConstructHook_String,
  2430.                                                                     MUIA_List_DestructHook,MUIV_List_DestructHook_String,
  2431.                                                                     MUIA_Background,MUII_ListBack,
  2432.                                                                     End,
  2433.                                                                 End,
  2434.                                                             Child,ST_Title=StringObject,
  2435.                                                                 StringFrame,
  2436.                                                                 MUIA_ShortHelp,glstr(MSG_HelpTitle),
  2437.                                                                 MUIA_String_MaxLen,127,
  2438.                                                                 MUIA_String_AttachedList,LV_TitleList,
  2439.                                                                 End,
  2440.                                                             Child,ColGroup(4),
  2441.                                                                 Child,Label1(glstr(MSG_AutoPlay)),
  2442.                                                                 Child,CH_AutoPlay=CheckMarkH(0,glstr(MSG_HelpAutoPlay)),
  2443.                                                                 Child,Label1(glstr(MSG_AutoProgram)),
  2444.                                                                 Child,CH_AutoProgram=CheckMarkH(0,glstr(MSG_HelpAutoProgram)),
  2445.                                                                 Child,Label1(glstr(MSG_AutoShuffle)),
  2446.                                                                 Child,CH_AutoShuffle=CheckMarkH(0,glstr(MSG_HelpAutoShuffle)),
  2447.                                                                 Child,Label1(glstr(MSG_AutoRepeat)),
  2448.                                                                 Child,CH_AutoRepeat=CheckMarkH(0,glstr(MSG_HelpAutoRepeat)),
  2449.                                                                 End,
  2450.                                                             Child,HGroup,
  2451.                                                                 Child,BT_Use=SimpleButton(glstr(MSG_Use)),
  2452.                                                                 Child,BT_Save=SimpleButton(glstr(MSG_Save)),
  2453.                                                                 Child,BT_Cancel=SimpleButton(glstr(MSG_Cancel)),
  2454.                                                                 End,
  2455.                                                             End,
  2456.                                                         End,
  2457.                                                     SubWindow,
  2458.                                                         WI_Program=WindowObject,
  2459.                                                         MUIA_Window_Title,glstr(MSG_ProgramWindowTitle),
  2460.                                                         MUIA_Window_ID,MAKE_ID('P','R','O','G'),
  2461.                                                         WindowContents,VGroup,
  2462.                                                             MUIA_Font,(customfonts)?(ULONG)normalfont:MUIV_Font_Normal,
  2463.                                                             MUIA_Background,MUII_WindowBack,
  2464.                                                             Child,HGroup,
  2465.                                                                 Child,VGroup,
  2466.                                                                     Child,TextObject,
  2467.                                                                         MUIA_Font,(customfonts)?(ULONG)titlefont:MUIV_Font_Title,
  2468.                                                                         MUIA_Text_Contents,glstr(MSG_TitleList),
  2469.                                                                         MUIA_Text_PreParse,"\33c",
  2470.                                                                         End,
  2471.                                                                     Child,LV_PList=ListviewObject,
  2472.                                                                         MUIA_Listview_DragType,MUIV_Listview_DragType_Immediate,
  2473.                                                                         MUIA_Listview_List,LI_PList=ListObject,
  2474.                                                                             MUIA_Font,(customfonts)?(ULONG)listfont:MUIV_Font_List,
  2475.                                                                             InputListFrame,
  2476.                                                                             MUIA_ShortHelp,glstr(MSG_HelpPTitles),
  2477.                                                                             MUIA_List_ConstructHook,MUIV_List_ConstructHook_String,
  2478.                                                                             MUIA_List_DestructHook,MUIV_List_DestructHook_String,
  2479.                                                                             MUIA_Background,MUII_ListBack,
  2480.                                                                             End,
  2481.                                                                         End,
  2482.                                                                     End,
  2483.                                                                 Child,VGroup,
  2484.                                                                     MUIA_Weight,0,
  2485.                                                                     Child,VSpace(0),
  2486.                                                                     Child,BT_PNew=SimpleButton(glstr(MSG_New)),
  2487.                                                                     Child,BT_PDelete=SimpleButton(glstr(MSG_Delete)),
  2488.                                                                     Child,BT_PTop=SimpleButton(glstr(MSG_Top)),
  2489.                                                                     Child,BT_PUp=SimpleButton(glstr(MSG_Up)),
  2490.                                                                     Child,BT_PDown=SimpleButton(glstr(MSG_Down)),
  2491.                                                                     Child,BT_PBottom=SimpleButton(glstr(MSG_Bottom)),
  2492.                                                                     Child,BT_PAll=SimpleButton(glstr(MSG_All)),
  2493.                                                                     Child,VSpace(0),
  2494.                                                                     End,
  2495.                                                                 Child,VGroup,
  2496.                                                                     Child,TextObject,
  2497.                                                                         MUIA_Font,(customfonts)?(ULONG)titlefont:MUIV_Font_Title,
  2498.                                                                         MUIA_Text_Contents,glstr(MSG_ProgramList),
  2499.                                                                         MUIA_Text_PreParse,"\33c",
  2500.                                                                         End,
  2501.                                                                     Child,LV_Program=ListviewObject,
  2502.                                                                         MUIA_Listview_DragType,MUIV_Listview_DragType_Immediate,
  2503.                                                                         MUIA_Listview_List,NewObject(CL_ProgramList->mcc_Class,NULL,
  2504.                                                                             MUIA_Font,(customfonts)?(ULONG)listfont:MUIV_Font_List,
  2505.                                                                             InputListFrame,
  2506.                                                                             MUIA_List_DragSortable,TRUE,
  2507.                                                                             MUIA_ShortHelp,glstr(MSG_HelpProgramList),
  2508.                                                                             MUIA_List_ConstructHook,MUIV_List_ConstructHook_String,
  2509.                                                                             MUIA_List_DestructHook,MUIV_List_DestructHook_String,
  2510.                                                                             MUIA_Background,MUII_ListBack,
  2511.                                                                             TAG_DONE),
  2512.                                                                         End,
  2513.                                                                     End,
  2514.                                                                 End,
  2515.                                                             Child,HGroup,
  2516.                                                                 Child,BT_PUse=SimpleButton(glstr(MSG_Use)),
  2517.                                                                 Child,BT_PSave=SimpleButton(glstr(MSG_Save)),
  2518.                                                                 Child,BT_PCancel=SimpleButton(glstr(MSG_Cancel)),
  2519.                                                                 End,
  2520.                                                             End,
  2521.                                                         End,
  2522.                                                     End;
  2523.                                             }
  2524.                                             else
  2525.                                             {
  2526.                                                 errorstr=glstr(MSG_FailApplication);
  2527.                                             }
  2528.  
  2529.                                             if(AP_SCDP)
  2530.                                             {
  2531.                                                 SetUpHotKeys();
  2532.  
  2533.                                                 if(popupflag==0)
  2534.                                                     set(AP_SCDP,MUIA_Application_Iconified,TRUE);
  2535.                                                 if(popupflag==1)
  2536.                                                     set(AP_SCDP,MUIA_Application_Iconified,FALSE);
  2537.  
  2538.                                                 set(BT_ProgramR,MUIA_ShortHelp,glstr(MSG_HelpProgramR));
  2539.                                                 set(BT_List,MUIA_ShortHelp,glstr(MSG_HelpList));
  2540.                                                 set(BT_Use,MUIA_ShortHelp,glstr(MSG_HelpUse));
  2541.                                                 set(BT_Save,MUIA_ShortHelp,glstr(MSG_HelpSave));
  2542.                                                 set(BT_Cancel,MUIA_ShortHelp,glstr(MSG_HelpCancel));
  2543.                                                 set(BT_PUse,MUIA_ShortHelp,glstr(MSG_HelpUse));
  2544.                                                 set(BT_PSave,MUIA_ShortHelp,glstr(MSG_HelpSave));
  2545.                                                 set(BT_PCancel,MUIA_ShortHelp,glstr(MSG_HelpCancel));
  2546.                                                 set(BT_PNew,MUIA_ShortHelp,glstr(MSG_HelpNew));
  2547.                                                 set(BT_PDelete,MUIA_ShortHelp,glstr(MSG_HelpDelete));
  2548.                                                 set(BT_PTop,MUIA_ShortHelp,glstr(MSG_HelpTop));
  2549.                                                 set(BT_PUp,MUIA_ShortHelp,glstr(MSG_HelpUp));
  2550.                                                 set(BT_PDown,MUIA_ShortHelp,glstr(MSG_HelpDown));
  2551.                                                 set(BT_PBottom,MUIA_ShortHelp,glstr(MSG_HelpBottom));
  2552.                                                 set(BT_PAll,MUIA_ShortHelp,glstr(MSG_HelpAll));
  2553.  
  2554.                                                 DoMethod(WI_SCDP,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,AP_SCDP,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
  2555.                                                 DoMethod(WI_List,MUIM_Window_SetCycleChain,ST_Artist,ST_CDTitle,ST_Title,CH_AutoPlay,CH_AutoProgram,CH_AutoShuffle,CH_AutoRepeat,BT_Use,BT_Save,BT_Cancel,NULL);
  2556.                                                 DoMethod(WI_Program,MUIM_Window_SetCycleChain,LV_PList,BT_PNew,BT_PDelete,BT_PTop,BT_PUp,BT_PDown,BT_PBottom,LV_Program,BT_PUse,BT_PSave,BT_PCancel,NULL);
  2557.  
  2558.                                                 DoMethod(BT_Shuffle,MUIM_Notify,MUIA_Selected,TRUE,BT_ProgramL,3,MUIM_Set,MUIA_Selected,FALSE);
  2559.                                                 DoMethod(BT_ProgramL,MUIM_Notify,MUIA_Selected,TRUE,BT_Shuffle,3,MUIM_Set,MUIA_Selected,FALSE);
  2560.                                                 DoMethod(CH_AutoShuffle,MUIM_Notify,MUIA_Selected,TRUE,CH_AutoProgram,3,MUIM_Set,MUIA_Selected,FALSE);
  2561.                                                 DoMethod(CH_AutoProgram,MUIM_Notify,MUIA_Selected,TRUE,CH_AutoShuffle,3,MUIM_Set,MUIA_Selected,FALSE);
  2562.  
  2563.                                                 DoMethod(BT_List,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_List);
  2564.                                                 DoMethod(BT_ProgramR,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_ProgramR);
  2565.                                                 DoMethod(BT_Play,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_Play);
  2566.                                                 DoMethod(BT_Pause,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_Pause);
  2567.                                                 DoMethod(BT_Stop,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_Stop);
  2568.                                                 DoMethod(BT_Previous,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_Previous);
  2569.                                                 DoMethod(BT_Next,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_Next);
  2570.                                                 DoMethod(BT_Rewind,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_Rewind);
  2571.                                                 DoMethod(BT_FastForward,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_FastForward);
  2572.                                                 DoMethod(BT_Eject,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_Eject);
  2573.                                                 DoMethod(BT_ProgramL,MUIM_Notify,MUIA_Selected,MUIV_EveryTime,AP_SCDP,2,MUIM_Application_ReturnID,ID_ProgramL);
  2574.                                                 DoMethod(BT_Shuffle,MUIM_Notify,MUIA_Selected,MUIV_EveryTime,AP_SCDP,2,MUIM_Application_ReturnID,ID_Shuffle);
  2575.                                                 DoMethod(SL_Volume,MUIM_Notify,MUIA_Slider_Level,MUIV_EveryTime,AP_SCDP,2,MUIM_Application_ReturnID,ID_Volume);
  2576.  
  2577.                                                 DoMethod(BT_Use,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_Use);
  2578.                                                 DoMethod(BT_Save,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_Save);
  2579.                                                 DoMethod(BT_Cancel,MUIM_Notify,MUIA_Pressed,FALSE,WI_List,3,MUIM_Set,MUIA_Window_Open,FALSE);
  2580.                                                 DoMethod(WI_List,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,WI_List,3,MUIM_Set,MUIA_Window_Open,FALSE);
  2581.  
  2582.                                                 DoMethod(LV_TrackSelect,MUIM_Notify,MUIA_Listview_DoubleClick,TRUE,AP_SCDP,2,MUIM_Application_ReturnID,ID_TrackSelect);
  2583.                                                 DoMethod(LV_ProgramSelect,MUIM_Notify,MUIA_Listview_DoubleClick,TRUE,AP_SCDP,2,MUIM_Application_ReturnID,ID_ProgramSelect);
  2584.                                                 DoMethod(LV_TitleList,MUIM_Notify,MUIA_List_Active,MUIV_EveryTime,AP_SCDP,2,MUIM_Application_ReturnID,ID_ChangeActive);
  2585.                                                 DoMethod(ST_Title,MUIM_Notify,MUIA_String_Acknowledge,MUIV_EveryTime,AP_SCDP,2,MUIM_Application_ReturnID,ID_Confirm);
  2586.                                                 DoMethod(ST_Title,MUIM_Notify,MUIA_String_Acknowledge,MUIV_EveryTime,WI_List,3,MUIM_Set,MUIA_Window_ActiveObject,ST_Title);
  2587.                                                 DoMethod(ST_Artist,MUIM_Notify,MUIA_String_Acknowledge,MUIV_EveryTime,WI_List,3,MUIM_Set,MUIA_Window_ActiveObject,ST_CDTitle);
  2588.                                                 DoMethod(ST_CDTitle,MUIM_Notify,MUIA_String_Acknowledge,MUIV_EveryTime,WI_List,3,MUIM_Set,MUIA_Window_ActiveObject,ST_Title);
  2589.  
  2590.                                                 DoMethod(BT_PUse,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_PUse);
  2591.                                                 DoMethod(BT_PSave,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_PSave);
  2592.                                                 DoMethod(BT_PCancel,MUIM_Notify,MUIA_Pressed,FALSE,WI_Program,3,MUIM_Set,MUIA_Window_Open,FALSE);
  2593.                                                 DoMethod(WI_Program,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,WI_Program,3,MUIM_Set,MUIA_Window_Open,FALSE);
  2594.                                                 DoMethod(LV_PList,MUIM_Notify,MUIA_Listview_DoubleClick,MUIV_EveryTime,AP_SCDP,2,MUIM_Application_ReturnID,ID_PInsert);
  2595.                                                 DoMethod(BT_PNew,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,1,MUIM_List_Clear);
  2596.                                                 DoMethod(BT_PDelete,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,2,MUIM_List_Remove,MUIV_List_Remove_Active);
  2597.                                                 DoMethod(BT_PTop,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,3,MUIM_List_Move,MUIV_List_Move_Active,MUIV_List_Move_Top);
  2598.                                                 DoMethod(BT_PTop,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,3,MUIM_Set,MUIA_List_Active,MUIV_List_Active_Top);
  2599.                                                 DoMethod(BT_PUp,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,3,MUIM_List_Move,MUIV_List_Move_Active,MUIV_List_Move_Previous);
  2600.                                                 DoMethod(BT_PUp,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,3,MUIM_Set,MUIA_List_Active,MUIV_List_Active_Up);
  2601.                                                 DoMethod(BT_PDown,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,3,MUIM_List_Move,MUIV_List_Move_Active,MUIV_List_Move_Next);
  2602.                                                 DoMethod(BT_PDown,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,3,MUIM_Set,MUIA_List_Active,MUIV_List_Active_Down);
  2603.                                                 DoMethod(BT_PBottom,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,3,MUIM_List_Move,MUIV_List_Move_Active,MUIV_List_Move_Bottom);
  2604.                                                 DoMethod(BT_PBottom,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,3,MUIM_Set,MUIA_List_Active,MUIV_List_Active_Bottom);
  2605.                                                 DoMethod(BT_PAll,MUIM_Notify,MUIA_Pressed,FALSE,LV_Program,1,MUIM_List_Clear);
  2606.                                                 DoMethod(BT_PAll,MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_PAll);
  2607.                                                 DoMethod(LV_Program,MUIM_Notify,MUIA_Listview_DoubleClick,MUIV_EveryTime,LV_Program,2,MUIM_List_Remove,MUIV_List_Remove_Active);
  2608.  
  2609.                                                 for(a=0;a<buttonscriptsno;a++)
  2610.                                                     DoMethod(BT_A[a],MUIM_Notify,MUIA_Pressed,FALSE,AP_SCDP,2,MUIM_Application_ReturnID,ID_A1+a);
  2611.  
  2612.                                                 set(BT_List,MUIA_Disabled,TRUE);
  2613.                                                 set(BT_ProgramR,MUIA_Disabled,TRUE);
  2614.                                                 set(WI_SCDP,MUIA_Window_Open,TRUE);
  2615.  
  2616.                                                 /* if(!volumecontrol)
  2617.                                                     set(SL_Volume,MUIA_Disabled,TRUE);*/
  2618.  
  2619.                                                 /*set(WI_Program,MUIA_Window_Open,TRUE);*/
  2620.  
  2621.                                                 i=vamos=TRUE;
  2622.                                                 signals=0;
  2623.                                                 CDSetVolume(-1);
  2624.                                                 
  2625.                                                 StartARexx();
  2626.  
  2627.                                                 if(*scriptonstart)
  2628.                                                 {
  2629.                                                     LaunchARexxScript(scriptonstart);
  2630.                                                 }
  2631.  
  2632.                                                 while(i || rxmsgs)
  2633.                                                 {
  2634.                                                     if(signals&(1<<tmsgport->mp_SigBit))
  2635.                                                     {
  2636.                                                         struct RexxMsg *rxmsg=NULL;
  2637.                                                         
  2638.                                                         GetMsg(tmsgport);
  2639.  
  2640.                                                         if(rexxok && rxmsgs)
  2641.                                                         {
  2642.                                                             while(rxmsg=GetMsg(rxmp))
  2643.                                                             {
  2644.                                                                 ClearRexxMsg(rxmsg,1);
  2645.                                                                 DeleteRexxMsg(rxmsg);
  2646.                                                                 rxmsgs--;
  2647.                                                             }
  2648.                                                         }
  2649.                                                         
  2650.                                                         if(delayedplay)
  2651.                                                         {
  2652.                                                             actuate=0;
  2653.                                                             delayedplay--;
  2654.                                                             if(!delayedplay)
  2655.                                                             {
  2656.                                                                 int qq;
  2657.                                                                 
  2658.                                                                 get(CH_AutoPlay,MUIA_Selected,&qq);
  2659.                                                                 
  2660.                                                                 if(qq)
  2661.                                                                 {
  2662.                                                                     DoMethod(AP_SCDP,MUIM_Application_ReturnID,ID_Play);
  2663.                                                                     skip=3;
  2664.                                                                 }
  2665.                                                             }
  2666.                                                         }
  2667.                                                         
  2668.                                                         if(actuate)
  2669.                                                         {
  2670.                                                             get(BT_Repeat,MUIA_Selected,&a);
  2671.                                                             if(pstatus==NORMAL)
  2672.                                                             {
  2673.                                                                 if(a)
  2674.                                                                 {
  2675.                                                                     track=1;
  2676.                                                                     while((TOCflags[track-1]&1) && track<=TOClength)
  2677.                                                                         track++;
  2678.                                                                     if(track>TOClength)
  2679.                                                                     {
  2680.                                                                         CDStop();
  2681.                                                                         track=0;
  2682.                                                                     }
  2683.                                                                     else
  2684.                                                                     {
  2685.                                                                         CDPlay(TOCaddr[track-1],TOCaddr[TOClength]-TOCaddr[track-1]);
  2686.                                                                         CDGetPos(FALSE);
  2687.                                                                     }
  2688.                                                                 }
  2689.                                                                 else
  2690.                                                                 {
  2691.                                                                     CDStop();
  2692.                                                                     track=0;
  2693.                                                                 }
  2694.                                                             }
  2695.                                                             else
  2696.                                                             {
  2697.                                                                 pactual++;
  2698.                                                                 if(!programmed[pactual-1] && a)
  2699.                                                                 {
  2700.                                                                     pactual=1;
  2701.                                                                     if(pstatus==SHUFFLE)
  2702.                                                                         DoShuffle();
  2703.                                                                 }
  2704.                                                                 if(!programmed[pactual-1])
  2705.                                                                 {
  2706.                                                                     CDStop();
  2707.                                                                     track=0;
  2708.                                                                 }
  2709.                                                                 else
  2710.                                                                 {
  2711.                                                                     track=programmed[pactual-1];
  2712.                                                                     CDPlay(TOCaddr[track-1],TOCaddr[TOClength]-TOCaddr[track-1]);
  2713.                                                                 }
  2714.                                                             }
  2715.                                                             actuate=0;
  2716.                                                         }
  2717.  
  2718.                                                         CDGetPos(TRUE);
  2719.                                                         if(useraction==-1)
  2720.                                                             useraction=0;
  2721.                                                     }
  2722.  
  2723.                                                     b=DoMethod(AP_SCDP,MUIM_Application_Input,&signals);
  2724.                                                     if((b==ID_Next || b==ID_Previous) && status!=PLAYING)
  2725.                                                         b=ID_Play;
  2726.                                                     switch(b)
  2727.                                                     {
  2728.                                                         case MEN_QUIT:
  2729.                                                         case MUIV_Application_ReturnID_Quit:
  2730.                                                             if(*scriptonquit && !quitting)
  2731.                                                             {
  2732.                                                                 LaunchARexxScript(scriptonquit);
  2733.                                                             }
  2734.                                                             i=FALSE;
  2735.                                                             quitting=TRUE;
  2736.                                                             break;
  2737.                                                         case MEN_ABOUT:
  2738.                                                             MUI_Request(AP_SCDP,WI_SCDP,0,NULL,glstr(MSG_AboutGadget),glstr(MSG_AboutText));
  2739.                                                             break;
  2740.                                                         case MEN_ABOUTMUI:
  2741.                                                             if(!WI_AboutMUI)
  2742.                                                                 WI_AboutMUI=AboutmuiObject,
  2743.                                                                     MUIA_Window_RefWindow,WI_SCDP,
  2744.                                                                     MUIA_Aboutmui_Application,AP_SCDP,
  2745.                                                                     End;
  2746.                                                             if(WI_AboutMUI)
  2747.                                                                 set(WI_AboutMUI,MUIA_Window_Open,TRUE);
  2748.                                                             else
  2749.                                                                 DisplayBeep(0);
  2750.                                                             break;
  2751.                                                         case MEN_MUI:
  2752.                                                             DoMethod(AP_SCDP,MUIM_Application_OpenConfigWindow,0);
  2753.                                                             break;
  2754.                                                         case MEN_EXECUTE:
  2755.                                                             {
  2756.                                                                 struct FileRequester *fr;
  2757.                                                                 char buff[256];
  2758.                                                                 
  2759.                                                                 useraction=1;
  2760.                                                                 
  2761.                                                                 fr=AllocAslRequestTags(ASL_FileRequest,ASLFR_TitleText,glstr(MSG_SelectARexx),ASLFR_InitialDrawer,"Rexx",ASLFR_InitialPattern,"#?.scdp",ASLFR_DoPatterns,TRUE,ASLFR_RejectIcons,TRUE);
  2762.                                                                 if(fr)
  2763.                                                                 {
  2764.                                                                     set(AP_SCDP,MUIA_Application_Sleep,TRUE);
  2765.                                                                     if(AslRequest(fr,NULL))
  2766.                                                                     {
  2767.                                                                         strcpy(buff,fr->fr_Drawer);
  2768.                                                                         if(strlen(buff) && buff[strlen(buff)-1]!='/' && buff[strlen(buff)-1]!=':')
  2769.                                                                         {
  2770.                                                                             strcat(buff,"/");
  2771.                                                                         }
  2772.                                                                         strcat(buff,fr->fr_File);
  2773.                                                                         LaunchARexxScript(buff);
  2774.                                                                     }
  2775.                                                                     set(AP_SCDP,MUIA_Application_Sleep,FALSE);
  2776.                                                                     FreeAslRequest(fr);
  2777.                                                                 }
  2778.                                                             }
  2779.                                                             break;
  2780.                                                         case MEN_A1:
  2781.                                                         case MEN_A2:
  2782.                                                         case MEN_A3:
  2783.                                                         case MEN_A4:
  2784.                                                         case MEN_A5:
  2785.                                                         case MEN_A6:
  2786.                                                         case MEN_A7:
  2787.                                                         case MEN_A8:
  2788.                                                             useraction=1;
  2789.                                                             LaunchARexxScript(menuscripts[b-MEN_A1]);
  2790.                                                             break;
  2791.                                                         case ID_A1:
  2792.                                                         case ID_A2:
  2793.                                                         case ID_A3:
  2794.                                                         case ID_A4:
  2795.                                                         case ID_A5:
  2796.                                                         case ID_A6:
  2797.                                                         case ID_A7:
  2798.                                                         case ID_A8:
  2799.                                                             useraction=1;
  2800.                                                             LaunchARexxScript(buttonscripts[b-ID_A1]);
  2801.                                                             break;
  2802.                                                         case ID_Volume:
  2803.                                                             get(SL_Volume,MUIA_Slider_Level,&a);
  2804.                                                             CDSetVolume(a);
  2805.                                                             break;
  2806.                                                         case ID_Play:
  2807.                                                             useraction=(useraction!=-1);
  2808.                                                             switch(pstatus)
  2809.                                                             {
  2810.                                                                 case NORMAL:
  2811.                                                                     switch(status)
  2812.                                                                     {
  2813.                                                                         case STOPPED:
  2814.                                                                             track=1;
  2815.                                                                             while((TOCflags[track-1]&1) && track<=TOClength)
  2816.                                                                                 track++;
  2817.                                                                             if(track>TOClength)
  2818.                                                                             {
  2819.                                                                                 CDStop();
  2820.                                                                                 track=0;
  2821.                                                                             }
  2822.                                                                             else
  2823.                                                                             {
  2824.                                                                                 CDPlay(TOCaddr[track-1],TOCaddr[TOClength]-TOCaddr[track-1]);
  2825.                                                                                 CDGetPos(FALSE);
  2826.                                                                             }
  2827.                                                                             break;
  2828.                                                                         case PAUSED:
  2829.                                                                             CDResume();
  2830.                                                                             break;
  2831.                                                                     }
  2832.                                                                     break;
  2833.                                                                 case SHUFFLE:
  2834.                                                                     switch(status)
  2835.                                                                     {
  2836.                                                                         case STOPPED:
  2837.                                                                             DoShuffle();
  2838.                                                                             if(programmed[0])
  2839.                                                                             {
  2840.                                                                                 a=programmed[0];
  2841.                                                                                 pactual=1;
  2842.                                                                                 CDPlay(TOCaddr[a-1],TOCaddr[TOClength]-TOCaddr[a-1]);
  2843.                                                                                 CDGetPos(FALSE);
  2844.                                                                             }
  2845.                                                                             break;
  2846.                                                                         case PAUSED:
  2847.                                                                             CDResume();
  2848.                                                                             break;
  2849.                                                                     }
  2850.                                                                     break;
  2851.                                                                 case PROGRAM:
  2852.                                                                     switch(status)
  2853.                                                                     {
  2854.                                                                         case STOPPED:
  2855.                                                                             DoProgram();
  2856.                                                                             if(programmed[0])
  2857.                                                                             {
  2858.                                                                                 a=programmed[0];
  2859.                                                                                 pactual=1;
  2860.                                                                                 CDPlay(TOCaddr[a-1],TOCaddr[TOClength]-TOCaddr[a-1]);
  2861.                                                                                 CDGetPos(FALSE);
  2862.                                                                             }
  2863.                                                                             break;
  2864.                                                                         case PAUSED:
  2865.                                                                             CDResume();
  2866.                                                                             break;
  2867.                                                                     }
  2868.                                                                     break;
  2869.                                                             }
  2870.                                                             break;
  2871.                                                         case ID_Eject:
  2872.                                                             useraction=1;
  2873.                                                             if(trayout)
  2874.                                                             {
  2875.                                                                 CDLoad();
  2876.                                                                 trayout=FALSE;
  2877.                                                             }
  2878.                                                             else
  2879.                                                             {
  2880.                                                                 CDEject();
  2881.                                                                 trayout=TRUE;
  2882.                                                             }
  2883.                                                             break;
  2884.                                                         case ID_Pause:
  2885.                                                             useraction=(useraction!=-1);
  2886.                                                             if(status==PAUSED)
  2887.                                                                 CDResume();
  2888.                                                             else
  2889.                                                                 CDPause();
  2890.                                                             break;
  2891.                                                         case ID_Stop:
  2892.                                                             useraction=(useraction!=-1);
  2893.                                                             CDStop();
  2894.                                                             break;
  2895.                                                         case ID_Rewind:
  2896.                                                             useraction=(useraction!=-1);
  2897.                                                             if(status==PLAYING && actualindex<14400000 && actualindex>(75*5))
  2898.                                                             {
  2899.                                                                 CDGetPos(FALSE);
  2900.                                                                 totalindex-=(75*5);
  2901.                                                                 CDPlay(totalindex,TOCaddr[TOClength]-totalindex);
  2902.                                                                 CDGetPos(FALSE);
  2903.                                                             }
  2904.                                                             break;
  2905.                                                         case ID_FastForward:
  2906.                                                             useraction=(useraction!=-1);
  2907.                                                             if(status==PLAYING && totalindex<TOCaddr[track]-(75*5) && actualindex>0)
  2908.                                                             {
  2909.                                                                 CDGetPos(FALSE);
  2910.                                                                 totalindex+=(75*5);
  2911.                                                                 CDPlay(totalindex,TOCaddr[TOClength]-totalindex);
  2912.                                                                 CDGetPos(FALSE);
  2913.                                                             }
  2914.                                                             break;
  2915.                                                         case ID_Previous:
  2916.                                                             useraction=(useraction!=-1);
  2917.                                                             if(status==PLAYING)
  2918.                                                             {
  2919.                                                                 CDGetPos(FALSE);
  2920.                                                                 if(totalindex-TOCaddr[track-1]>(75*5))
  2921.                                                                 {
  2922.                                                                     CDPlay(TOCaddr[track-1],TOCaddr[TOClength]-TOCaddr[track-1]);
  2923.                                                                 }
  2924.                                                                 else
  2925.                                                                 {
  2926.                                                                     switch(pstatus)
  2927.                                                                     {
  2928.                                                                         case NORMAL:
  2929.                                                                             if(onevalid)
  2930.                                                                             {
  2931.                                                                                 track--;
  2932.                                                                                 if(!track)
  2933.                                                                                     track=TOClength;
  2934.                                                                                 while(TOCflags[track-1])
  2935.                                                                                 {
  2936.                                                                                     track--;
  2937.                                                                                     if(!track)
  2938.                                                                                         track=TOClength;
  2939.                                                                                 }
  2940.                                                                                 CDPlay(TOCaddr[track-1],TOCaddr[TOClength]-TOCaddr[track-1]);
  2941.                                                                             }
  2942.                                                                             break;
  2943.                                                                         default:
  2944.                                                                             if(onevalid && pactual>1)
  2945.                                                                             {
  2946.                                                                                 pactual--;
  2947.                                                                                 track=programmed[pactual-1];
  2948.                                                                                 CDPlay(TOCaddr[track-1],TOCaddr[track]-TOCaddr[track-1]);
  2949.                                                                             }
  2950.                                                                             break;
  2951.                                                                     }
  2952.                                                                 }
  2953.                                                                 CDGetPos(FALSE);
  2954.                                                             }
  2955.                                                             break;
  2956.                                                         case ID_Next:
  2957.                                                             useraction=(useraction!=-1);
  2958.                                                             if(status==PLAYING)
  2959.                                                             {
  2960.                                                                 CDGetPos(FALSE);
  2961.                                                                 {
  2962.                                                                     switch(pstatus)
  2963.                                                                     {
  2964.                                                                         case NORMAL:
  2965.                                                                             if(onevalid)
  2966.                                                                             {
  2967.                                                                                 track++;
  2968.                                                                                 if(track>TOClength)
  2969.                                                                                     track=1;
  2970.                                                                                 while(TOCflags[track-1])
  2971.                                                                                 {
  2972.                                                                                     track++;
  2973.                                                                                     if(track>TOClength)
  2974.                                                                                         track=1;
  2975.                                                                                 }
  2976.                                                                                 CDPlay(TOCaddr[track-1],TOCaddr[TOClength]-TOCaddr[track-1]);
  2977.                                                                             }
  2978.                                                                             break;
  2979.                                                                         default:
  2980.                                                                             if(onevalid && programmed[pactual])
  2981.                                                                             {
  2982.                                                                                 pactual++;
  2983.                                                                                 track=programmed[pactual-1];
  2984.                                                                                 CDPlay(TOCaddr[track-1],TOCaddr[track]-TOCaddr[track-1]);
  2985.                                                                             }
  2986.                                                                             break;
  2987.                                                                     }
  2988.                                                                 }
  2989.                                                                 CDGetPos(FALSE);
  2990.                                                             }
  2991.                                                             break;
  2992.                                                         case ID_TrackSelect:
  2993.                                                             useraction=1;
  2994.                                                             get(LV_TrackSelect,MUIA_List_Active,&a);
  2995.                                                             if(a>=0 && a<TOClength && !TOCflags[a])
  2996.                                                             {
  2997.                                                                 pstatus=NORMAL;
  2998.                                                                 set(BT_ProgramL,MUIA_Selected,FALSE);
  2999.                                                                 set(BT_Shuffle,MUIA_Selected,FALSE);
  3000.                                                                 track=a+1;
  3001.                                                                 CDPlay(TOCaddr[track-1],TOCaddr[TOClength]-TOCaddr[track-1]);
  3002.                                                                 CDGetPos(FALSE);
  3003.                                                             }
  3004.                                                             break;
  3005.                                                         case ID_ProgramSelect:
  3006.                                                             useraction=1;
  3007.                                                             set(BT_ProgramL,MUIA_Selected,TRUE);
  3008.                                                             if(pstatus!=PROGRAM)
  3009.                                                             {
  3010.                                                                 CDStop();
  3011.                                                             }
  3012.                                                             pstatus=PROGRAM;
  3013.                                                             DoProgram();
  3014.                                                             if(programmed[0])
  3015.                                                             {
  3016.                                                                 get(LV_ProgramSelect,MUIA_List_Active,&a);
  3017.                                                                 CDPlay(TOCaddr[programmed[a]-1],TOCaddr[TOClength]-TOCaddr[programmed[a]-1]);
  3018.                                                                 pactual=a+1;
  3019.                                                             }
  3020.                                                             else if(status!=STOPPED)
  3021.                                                                 CDStop();
  3022.                                                             break;
  3023.                                                         case ID_ProgramL:
  3024.                                                             useraction=(useraction!=-1);
  3025.                                                             get(BT_ProgramL,MUIA_Selected,&a);
  3026.                                                             if(a)
  3027.                                                             {
  3028.                                                                 pstatus=PROGRAM;
  3029.                                                                 DoProgram();
  3030.                                                                 if(status==PLAYING && programmed[0])
  3031.                                                                 {
  3032.                                                                     a=programmed[0];
  3033.  
  3034.                                                                     CDPlay(TOCaddr[a-1],TOCaddr[TOClength]-TOCaddr[a-1]);
  3035.                                                                     pactual=1;
  3036.                                                                 }
  3037.                                                                 else if(status!=STOPPED)
  3038.                                                                     CDStop();
  3039.                                                             }
  3040.                                                             else
  3041.                                                                 if(pstatus==PROGRAM)
  3042.                                                                     pstatus=NORMAL;
  3043.                                                             break;
  3044.                                                         case ID_Shuffle:
  3045.                                                             useraction=(useraction!=-1);
  3046.                                                             get(BT_Shuffle,MUIA_Selected,&a);
  3047.                                                             if(a)
  3048.                                                             {
  3049.                                                                 pstatus=SHUFFLE;
  3050.                                                                 DoShuffle();
  3051.                                                                 if(status==PLAYING && programmed[0])
  3052.                                                                 {
  3053.                                                                     a=programmed[0];
  3054.  
  3055.                                                                     CDPlay(TOCaddr[a-1],TOCaddr[a]-TOCaddr[a-1]);
  3056.                                                                     pactual=1;
  3057.                                                                 }
  3058.                                                                 else if(status!=STOPPED)
  3059.                                                                     CDStop();
  3060.                                                             }
  3061.                                                             else
  3062.                                                                 if(pstatus==SHUFFLE)
  3063.                                                                     pstatus=NORMAL;
  3064.                                                             break;
  3065.                                                         case ID_List:
  3066.                                                             FillList();
  3067.                                                             break;
  3068.                                                         case ID_ChangeActive:
  3069.                                                             DoMethod(LV_TitleList,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&strptr);
  3070.                                                             if(strptr)
  3071.                                                             {
  3072.                                                                 strcpy(buff,strptr);
  3073.                                                                 set(ST_Title,MUIA_String_Contents,buff+4);
  3074.                                                             }
  3075.                                                             break;
  3076.                                                         case ID_Confirm:
  3077.                                                             get(ST_Title,MUIA_String_Contents,&strptr);
  3078.                                                             get(LV_TitleList,MUIA_List_Active,&a);
  3079.                                                             if(a>=0 && a<TOClength)
  3080.                                                             {
  3081.                                                                 sprintf(buff,"%02d: %s",a+1,strptr);
  3082.                                                                 set(LV_TitleList,MUIA_List_Quiet,TRUE);
  3083.                                                                 DoMethod(LV_TitleList,MUIM_List_Remove,a);
  3084.                                                                 DoMethod(LV_TitleList,MUIM_List_InsertSingle,buff,a);
  3085.                                                                 set(LV_TitleList,MUIA_List_Quiet,FALSE);
  3086.                                                             }
  3087.                                                             break;
  3088.                                                         case ID_RexxSave:
  3089.                                                             {
  3090.                                                                 FILE *f;
  3091.                                                                 int a,b,c,d;
  3092.                                                                 set(WI_List,MUIA_Window_Open,FALSE);
  3093.                                                                 sprintf(buff,"%s%s",diskspath,TOCCDID);
  3094.                                                                 if(f=fopen(buff,"w"))
  3095.                                                                 {
  3096.                                                                     fprintf(f,"%s\n%s\n",TOCCDartist,TOCCDtitle);
  3097.                                                                     for(a=0;a<TOClength;a++)
  3098.                                                                     {
  3099.                                                                         DoMethod(LV_TrackSelect,MUIM_List_GetEntry,a,&strptr);
  3100.                                                                         fprintf(f,"%s\n",((char *)strptr)+4);
  3101.                                                                     }
  3102.                                                                     get(CH_AutoPlay,MUIA_Selected,&a);
  3103.                                                                     get(CH_AutoProgram,MUIA_Selected,&b);
  3104.                                                                     get(CH_AutoShuffle,MUIA_Selected,&c);
  3105.                                                                     get(CH_AutoRepeat,MUIA_Selected,&d);
  3106.                                                                     fprintf(f,"*%c\n",'0'+(a)+(b<<1)+(c<<2)+(d<<3));
  3107.                                                                     fclose(f);
  3108.                                                                 }
  3109.                                                             }
  3110.                                                             break;
  3111.                                                         case ID_Save:
  3112.                                                             {
  3113.                                                                 FILE *f;
  3114.                                                                 char *s1, *s2;
  3115.                                                                 int a,b,c,d;
  3116.                                                                 sprintf(buff,"%s%s",diskspath,TOCCDID);
  3117.                                                                 if(f=fopen(buff,"w"))
  3118.                                                                 {
  3119.                                                                     get(ST_Artist,MUIA_String_Contents,&s1);
  3120.                                                                     get(ST_CDTitle,MUIA_String_Contents,&s2);
  3121.                                                                     fprintf(f,"%s\n%s\n",s1,s2);
  3122.                                                                     for(a=0;a<TOClength;a++)
  3123.                                                                     {
  3124.                                                                         DoMethod(LV_TitleList,MUIM_List_GetEntry,a,&strptr);
  3125.                                                                         fprintf(f,"%s\n",((char *)strptr)+4);
  3126.                                                                     }
  3127.                                                                     get(CH_AutoPlay,MUIA_Selected,&a);
  3128.                                                                     get(CH_AutoProgram,MUIA_Selected,&b);
  3129.                                                                     get(CH_AutoShuffle,MUIA_Selected,&c);
  3130.                                                                     get(CH_AutoRepeat,MUIA_Selected,&d);
  3131.                                                                     fprintf(f,"*%c\n",'0'+(a)+(b<<1)+(c<<2)+(d<<3));
  3132.                                                                     fclose(f);
  3133.                                                                 }
  3134.                                                             }
  3135.                                                         case ID_Use:
  3136.                                                             get(ST_Artist,MUIA_String_Contents,&strptr);
  3137.                                                             strcpy(TOCCDartist,strptr);
  3138.                                                             get(ST_CDTitle,MUIA_String_Contents,&strptr);
  3139.                                                             strcpy(TOCCDtitle,strptr);
  3140.                                                             set(LV_TrackSelect,MUIA_List_Quiet,TRUE);
  3141.                                                             DoMethod(LV_TrackSelect,MUIM_List_Clear);
  3142.                                                             set(LV_PList,MUIA_List_Quiet,TRUE);
  3143.                                                             DoMethod(LV_PList,MUIM_List_Clear);
  3144.                                                             for(a=0;a<TOClength;a++)
  3145.                                                             {
  3146.                                                                 DoMethod(LV_TitleList,MUIM_List_GetEntry,a,&strptr);
  3147.                                                                 DoMethod(LV_TrackSelect,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  3148.                                                                 DoMethod(LV_PList,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  3149.                                                             }
  3150.                                                             set(LV_TrackSelect,MUIA_List_Quiet,FALSE);
  3151.                                                             set(LV_PList,MUIA_List_Quiet,FALSE);
  3152.                                                             set(LV_Program,MUIA_List_Quiet,TRUE);
  3153.                                                             DoMethod(LV_Program,MUIM_List_Clear);
  3154.                                                             set(LV_ProgramSelect,MUIA_List_Quiet,TRUE);
  3155.                                                             DoMethod(LV_ProgramSelect,MUIM_List_Clear);
  3156.                                                             a=0;
  3157.                                                             while(pprog[a])
  3158.                                                             {
  3159.                                                                 DoMethod(LV_TrackSelect,MUIM_List_GetEntry,pprog[a]-1,&strptr);
  3160.                                                                 DoMethod(LV_Program,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  3161.                                                                 DoMethod(LV_ProgramSelect,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  3162.                                                                 a++;
  3163.                                                             }
  3164.                                                             set(LV_Program,MUIA_List_Quiet,FALSE);
  3165.                                                             set(LV_ProgramSelect,MUIA_List_Quiet,FALSE);
  3166.  
  3167.                                                             refresh=TRUE;
  3168.                                                             set(WI_List,MUIA_Window_Open,FALSE);
  3169.                                                             CDGetPos(FALSE);
  3170.                                                             break;
  3171.                                                         case ID_PInsert:
  3172.                                                             DoMethod(LV_PList,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&strptr);
  3173.                                                             if(strptr)
  3174.                                                             {
  3175.                                                                 DoMethod(LV_Program,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  3176.                                                             }
  3177.                                                             break;
  3178.                                                         case ID_PAll:
  3179.                                                             a=0;
  3180.                                                             set(LV_Program,MUIA_List_Quiet,TRUE);
  3181.                                                             do
  3182.                                                             {
  3183.                                                                 DoMethod(LV_PList,MUIM_List_GetEntry,a,&strptr);
  3184.                                                                 if(strptr)
  3185.                                                                 {
  3186.                                                                     DoMethod(LV_Program,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  3187.                                                                     a++;
  3188.                                                                 }
  3189.                                                             }while(strptr);
  3190.                                                             set(LV_Program,MUIA_List_Quiet,FALSE);
  3191.                                                             break;
  3192.                                                         case ID_ProgramR:
  3193.                                                             set(LV_Program,MUIA_List_Quiet,TRUE);
  3194.                                                             DoMethod(LV_Program,MUIM_List_Clear);
  3195.                                                             a=0;
  3196.                                                             while(pprog[a])
  3197.                                                             {
  3198.                                                                 DoMethod(LV_TrackSelect,MUIM_List_GetEntry,pprog[a]-1,&strptr);
  3199.                                                                 DoMethod(LV_Program,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  3200.                                                                 a++;
  3201.                                                             }
  3202.                                                             set(LV_Program,MUIA_List_Quiet,FALSE);
  3203.                                                             set(WI_Program,MUIA_Window_ActiveObject,LV_PList);
  3204.                                                             set(WI_Program,MUIA_Window_Open,TRUE);
  3205.                                                             break;
  3206.                                                         case ID_PUse:
  3207.                                                             useraction=1;
  3208.                                                             a=0;
  3209.                                                             do
  3210.                                                             {
  3211.                                                                 DoMethod(LV_Program,MUIM_List_GetEntry,a,&strptr);
  3212.                                                                 if(strptr)
  3213.                                                                 {
  3214.                                                                     pprog[a]=(strptr[0]-'0')*10+strptr[1]-'0';
  3215.                                                                     a++;
  3216.                                                                 }
  3217.                                                             }while(strptr);
  3218.                                                             pprog[a]=0;
  3219.                                                             set(LV_ProgramSelect,MUIA_List_Quiet,TRUE);
  3220.                                                             DoMethod(LV_ProgramSelect,MUIM_List_Clear);
  3221.                                                             a=0;
  3222.                                                             while(pprog[a])
  3223.                                                             {
  3224.                                                                 DoMethod(LV_TrackSelect,MUIM_List_GetEntry,pprog[a]-1,&strptr);
  3225.                                                                 DoMethod(LV_ProgramSelect,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  3226.                                                                 a++;
  3227.                                                             }
  3228.                                                             set(LV_ProgramSelect,MUIA_List_Quiet,FALSE);
  3229.  
  3230.                                                             set(WI_Program,MUIA_Window_Open,FALSE);
  3231.                                                             break;
  3232.                                                         case ID_PSave:
  3233.                                                             useraction=1;
  3234.                                                             a=0;
  3235.                                                             do
  3236.                                                             {
  3237.                                                                 DoMethod(LV_Program,MUIM_List_GetEntry,a,&strptr);
  3238.                                                                 if(strptr)
  3239.                                                                 {
  3240.                                                                     pprog[a]=(strptr[0]-'0')*10+strptr[1]-'0';
  3241.                                                                     a++;
  3242.                                                                 }
  3243.                                                             }while(strptr);
  3244.                                                             pprog[a]=0;
  3245.                                                             set(LV_ProgramSelect,MUIA_List_Quiet,TRUE);
  3246.                                                             DoMethod(LV_ProgramSelect,MUIM_List_Clear);
  3247.                                                             a=0;
  3248.                                                             while(pprog[a])
  3249.                                                             {
  3250.                                                                 DoMethod(LV_TrackSelect,MUIM_List_GetEntry,pprog[a]-1,&strptr);
  3251.                                                                 DoMethod(LV_ProgramSelect,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  3252.                                                                 a++;
  3253.                                                             }
  3254.                                                             set(LV_ProgramSelect,MUIA_List_Quiet,FALSE);
  3255.                                                         case ID_PRexxSave:
  3256.                                                             sprintf(buff,"%s%s",diskspath,TOCCDID);
  3257.                                                             buff[strlen(diskspath)]='P';
  3258.                                                             buff[strlen(diskspath)+1]='R';
  3259.                                                             if(f=fopen(buff,"w"))
  3260.                                                             {
  3261.                                                                 a=0;
  3262.  
  3263.                                                                 while(pprog[a])
  3264.                                                                     putc(pprog[a++],f);
  3265.  
  3266.                                                                 fclose(f);
  3267.                                                             }
  3268.                                                             set(WI_Program,MUIA_Window_Open,FALSE);
  3269.                                                             break;
  3270.                                                         default:
  3271.                                                             break;
  3272.                                                     }
  3273.                                                     if(vamos)
  3274.                                                     {
  3275.                                                         CDGetPos(TRUE);
  3276.                                                         vamos=FALSE;
  3277.                                                     }
  3278.  
  3279.                                                     if((i || rxmsgs) && signals) signals=Wait(signals|(1<<tmsgport->mp_SigBit));
  3280.                                                 }
  3281.  
  3282.                                                 Wait(1<<tmsgport->mp_SigBit);
  3283.                                                 while(GetMsg(tmsgport));
  3284.                                                 
  3285.                                                 EndARexx();
  3286.                                             }
  3287.                                             else
  3288.                                             {
  3289.                                                 errorstr=glstr(MSG_FailApplication);
  3290.                                             }
  3291. /*
  3292. **                                          if(CL_ProgramList)
  3293. **                                              MUI_DeleteCustomClass(CL_ProgramList);
  3294. */
  3295.                                             FreeMem(TOCbuf,MAX_TOC_LEN);
  3296.                                         }
  3297.                                         else
  3298.                                             errorstr=glstr(MSG_FailMemory);
  3299.  
  3300.                                         FreeMem(scsidata,MAX_DATA_LEN);
  3301.                                     }
  3302.                                     else
  3303.                                         errorstr=glstr(MSG_FailMemory);
  3304.  
  3305.                                     CloseDevice((struct IORequest *)tioreq);
  3306.                                 }
  3307.                                 else
  3308.                                     errorstr=glstr(MSG_FailNoTimer);
  3309.  
  3310.                                 DeleteIORequest(tioreq);
  3311.                             }
  3312.                             else
  3313.                                 errorstr=glstr(MSG_FailNoIO);
  3314.  
  3315.                             DeleteMsgPort(tmsgport);
  3316.                         }
  3317.                         else
  3318.                             errorstr=glstr(MSG_FailNoMP);
  3319.  
  3320.                         FreeMem(scsisense,SENSE_LEN);
  3321.                     }
  3322.                     else
  3323.                         errorstr=glstr(MSG_FailMemory);
  3324.  
  3325.                     FreeMem(scsicmd,sizeof(SCSICMD));
  3326.                 }
  3327.                 else
  3328.                     errorstr=glstr(MSG_FailMemory);
  3329.  
  3330.                 CloseDevice((struct IORequest *)ioreq);
  3331.             }
  3332.             else
  3333.                 errorstr=glstr(MSG_FailNoDevice);
  3334.  
  3335.             DeleteIORequest(ioreq);
  3336.         }
  3337.         else
  3338.             errorstr=glstr(MSG_FailNoIO);
  3339.  
  3340.         DeleteMsgPort(msgport);
  3341.     }
  3342.     else
  3343.         errorstr=glstr(MSG_FailNoMP);
  3344.  
  3345.     if(mydo)
  3346.         FreeDiskObject(mydo);
  3347.  
  3348.     fail(AP_SCDP,errorstr);
  3349.  
  3350.     return 0;
  3351. }
  3352.  
  3353. int DoScsiCmd(UBYTE *data, int datasize, UBYTE *cmd, int cmdsize, UBYTE flags)
  3354. {
  3355.     ioreq->io_Length=sizeof(SCSICMD);
  3356.     ioreq->io_Data=scsicmd;
  3357.     ioreq->io_Command=HD_SCSICMD;
  3358.  
  3359.     scsicmd->scsi_Data=(APTR)data;
  3360.     scsicmd->scsi_Length=datasize;
  3361.     scsicmd->scsi_SenseActual=0;
  3362.     scsicmd->scsi_SenseData=scsisense;
  3363.     scsicmd->scsi_Command=cmd;
  3364.     scsicmd->scsi_CmdLength=cmdsize;
  3365.     scsicmd->scsi_Flags=flags;
  3366.  
  3367.     DoIO((struct IORequest *) ioreq);
  3368.  
  3369.     return ioreq->io_Error;
  3370. }
  3371.  
  3372. void CDEject(void)
  3373. {
  3374.     static SCSICMD6 command=
  3375.     {
  3376.         SCSI_CMD_SSU,
  3377.         0,
  3378.         PAD,
  3379.         PAD,
  3380.         0,
  3381.         PAD,
  3382.     };
  3383.  
  3384.     int err;
  3385.  
  3386.     command.b4=2;   /* I think this number is important: (0=STOP, 1=?, 2=EJECT, 3=LOAD, 4=STOP?)*/
  3387.  
  3388.     if(err=DoScsiCmd(0,0,(UBYTE *)&command,sizeof(command),SCSIF_READ|SCSIF_AUTOSENSE))
  3389.         return;
  3390. }
  3391.  
  3392. void CDLoad(void)
  3393. {
  3394.     static SCSICMD6 command=
  3395.     {
  3396.         SCSI_CMD_SSU,
  3397.         0,
  3398.         PAD,
  3399.         PAD,
  3400.         0,
  3401.         PAD,
  3402.     };
  3403.  
  3404.     int err;
  3405.  
  3406.     command.b4=3;   /* I think this number is important: (0=STOP, 1=?, 2=EJECT, 3=LOAD, 4=STOP?)*/
  3407.  
  3408.     if(err=DoScsiCmd(0,0,(UBYTE *)&command,sizeof(command),SCSIF_READ|SCSIF_AUTOSENSE))
  3409.         return;
  3410. }
  3411.  
  3412. void CDStop(void)
  3413. {
  3414.     static SCSICMD6 command=
  3415.     {
  3416.         SCSI_CMD_SSU,
  3417.         0,
  3418.         PAD,
  3419.         PAD,
  3420.         0,
  3421.         PAD,
  3422.     };
  3423.  
  3424.     int err;
  3425.  
  3426.     command.b4=0;   /* I think this number is important: (0=STOP, 1=?, 2=EJECT, 3=LOAD, 4=STOP?)*/
  3427.  
  3428.     if(status==PLAYING || status==PAUSED)
  3429.         status=STOPPED;
  3430.  
  3431.     userstop=TRUE;
  3432.  
  3433.     if(err=DoScsiCmd(0,0,(UBYTE *)&command,sizeof(command),SCSIF_READ|SCSIF_AUTOSENSE))
  3434.         return;
  3435. }
  3436.  
  3437. void CDGetPos(BOOL settimer)
  3438. {
  3439.     APTR *strptr;
  3440.     char buff[256];
  3441.     BOOL redraw=FALSE;
  3442.  
  3443.     static SCSICMD10 command=
  3444.     {
  3445.         SCSI_CMD_READSUBCHANNEL,
  3446.         0,
  3447.         0x40,
  3448.         0,
  3449.         PAD,
  3450.         PAD,
  3451.         0,
  3452.         0,0,
  3453.         PAD
  3454.     };
  3455.  
  3456.     int err;
  3457.     ULONG microsleft;
  3458.  
  3459.     command.b2=0x40;
  3460.     command.b3=1;
  3461.     command.b6=0;
  3462.     command.b7=255;
  3463.     command.b8=255;
  3464.  
  3465.     if(err=DoScsiCmd((UBYTE *)scsidata, MAX_DATA_LEN, (UBYTE *) &command, sizeof(command),SCSIF_READ|SCSIF_AUTOSENSE))
  3466.     {
  3467.         track=0;
  3468.         status=NODISK;
  3469.         actualindex=totalindex=0;
  3470.         pstatus=NORMAL;
  3471.         if(validTOC)
  3472.         {
  3473.             set(WI_List,MUIA_Window_Open,FALSE);
  3474.             set(WI_Program,MUIA_Window_Open,FALSE);
  3475.             set(BT_List,MUIA_Disabled,TRUE);
  3476.             set(BT_ProgramR,MUIA_Disabled,TRUE);
  3477.             set(BT_ProgramL,MUIA_Selected,FALSE);
  3478.             set(BT_Shuffle,MUIA_Selected,FALSE);
  3479.             set(BT_Repeat,MUIA_Selected,FALSE);
  3480.             set(TX_Track,MUIA_Text_Contents,"--");
  3481.             set(TX_TitleTime,MUIA_Text_Contents,"--:--/--:--");
  3482.             set(TX_CDTime,MUIA_Text_Contents,"--:--/--:--");
  3483.             set(TX_Artist,MUIA_Text_Contents,glstr(MSG_NoDisc));
  3484.             set(TX_Title,MUIA_Text_Contents,"");
  3485.             DoMethod(LV_TrackSelect,MUIM_List_Clear);
  3486.             DoMethod(LV_PList,MUIM_List_Clear);
  3487.             DoMethod(LV_Program,MUIM_List_Clear);
  3488.             DoMethod(LV_ProgramSelect,MUIM_List_Clear);
  3489.             pprog[0]=0;
  3490.             validTOC=0;
  3491.             microsleft=1000000;
  3492.         }
  3493.     }
  3494.     else
  3495.     {
  3496.         /* Now one looks at scsidata[1]. It may be:
  3497.             0x11:   Playing.
  3498.             0x12:   Pause.
  3499.             other:  Stopped.
  3500.  
  3501.            scsidata[6] has the number of the track being played.
  3502.  
  3503.            scsidata[12..15] contains the address which is being played (75ths of second from track start).
  3504.            scsidata[8..11] contains the address from the begin of the CD.
  3505.         */
  3506.         switch(scsidata[1])
  3507.         {
  3508.             case 0x11:
  3509.                 if(status!=PLAYING)
  3510.                 {
  3511.                     status=PLAYING;
  3512.                     redraw=TRUE;
  3513.                 }
  3514.                 if(track!=scsidata[6])
  3515.                 {
  3516.                     track=scsidata[6];
  3517.                     redraw=TRUE;
  3518.                 }
  3519.                 trayout=FALSE;
  3520.                 /* actualindex=(scsidata[12] << 24) | (scsidata[13] << 16) | (scsidata[14] << 8) | (scsidata[15]); */
  3521.                 totalindex=(scsidata[8] << 24) | (scsidata[9] << 16) | (scsidata[10] << 8) | (scsidata[11]);
  3522.                 actualindex=totalindex-TOCaddr[track-1];
  3523.                 microsleft=(75-(actualindex%75))*13333+25;
  3524.                 if(TOCaddr[track]-totalindex<80)
  3525.                 {
  3526.                     microsleft=(TOCaddr[track]-totalindex)*13333;
  3527.                     if(TOCaddr[TOClength]-totalindex<80 && !skip)
  3528.                         actuate=1;
  3529.                 }
  3530.                 if(pstatus!=NORMAL && track>programmed[pactual-1])
  3531.                 {
  3532.                     if(!skip)
  3533.                         actuate=2;
  3534.                     microsleft=1;
  3535.                 }
  3536.                 break;
  3537.             case 0x12:
  3538.                 status=PAUSED;
  3539.                 redraw=TRUE;
  3540.                 track=scsidata[6];
  3541.                 trayout=FALSE;
  3542.                 /* actualindex=(scsidata[12] << 24) | (scsidata[13] << 16) | (scsidata[14] << 8) | (scsidata[15]); */
  3543.                 totalindex=(scsidata[8] << 24) | (scsidata[9] << 16) | (scsidata[10] << 8) | (scsidata[11]);
  3544.                 actualindex=totalindex-TOCaddr[track-1];
  3545.                 microsleft=1000000;
  3546.                 break;
  3547.             default:
  3548.                 status=STOPPED;
  3549.                 redraw=TRUE;
  3550.                 trayout=FALSE;
  3551.                 actualindex=totalindex=0;
  3552.                 track=0;
  3553.                 microsleft=1000000;
  3554.                 if(!userstop && !skip)
  3555.                     actuate=3;
  3556.                 break;
  3557.         }
  3558.  
  3559.         if(!validTOC)
  3560.         {
  3561.             CDReadContents();
  3562.         }
  3563.  
  3564.         if(refresh)
  3565.         {
  3566.             redraw=TRUE;
  3567.             refresh=FALSE;
  3568.         }
  3569.  
  3570.         if(totalindex>=TOCaddr[TOClength])
  3571.         {
  3572.             if(!skip)
  3573.                 actuate=1;
  3574.             track=actualindex=totalindex=0;
  3575.         }
  3576.  
  3577.         if(track>0 && track<=TOClength)
  3578.         {
  3579.             if(pstatus==NORMAL || track==programmed[pactual-1])
  3580.                 set(LV_TrackSelect,MUIA_List_Active,track-1);
  3581.             if(pstatus==PROGRAM)
  3582.             {
  3583.                 if(track==programmed[pactual-1])
  3584.                 {
  3585.                     set(LV_ProgramSelect,MUIA_List_Active,pactual-1);
  3586.                 }
  3587.             }
  3588.             else
  3589.             {
  3590.                 set(LV_ProgramSelect,MUIA_List_Active,MUIV_List_Active_Off);
  3591.             }
  3592.             sprintf(buff,"%02d",track);
  3593.             set(TX_Track,MUIA_Text_Contents,buff);
  3594.             sprintf(buff,"%02.2d:%02.2d/%02.2d:%02.2d",min(actualindex/(60*75),99),(actualindex/75)%60,(TOCaddr[track]-TOCaddr[track-1])/(60*75),((TOCaddr[track]-TOCaddr[track-1])/75)%60 );
  3595.             set(TX_TitleTime,MUIA_Text_Contents,buff);
  3596.             sprintf(buff,"%02.2d:%02.2d/%02.2d:%02.2d",totalindex/(60*75),(totalindex/75)%60,(TOCaddr[TOClength])/(60*75),((TOCaddr[TOClength])/75)%60 );
  3597.             set(TX_CDTime,MUIA_Text_Contents,buff);
  3598.             if(redraw)
  3599.             {
  3600.                 sprintf(buff,"%s - %s",TOCCDartist,TOCCDtitle);
  3601.                 set(TX_Artist,MUIA_Text_Contents,buff);
  3602.                 DoMethod(LV_TrackSelect,MUIM_List_GetEntry,MUIV_List_GetEntry_Active,&strptr);
  3603.                 if(pstatus==NORMAL || track==programmed[pactual-1])
  3604.                     set(TX_Title,MUIA_Text_Contents,((char *)strptr)+4);
  3605.             }
  3606.         }
  3607.         else
  3608.         {
  3609.             if(redraw)
  3610.             {
  3611.                 set(LV_TrackSelect,MUIA_List_Active,MUIV_List_Active_Off);
  3612.                 set(LV_ProgramSelect,MUIA_List_Active,MUIV_List_Active_Off);
  3613.                 sprintf(buff,"--:--/%02.2d:%02.2d",(TOCaddr[TOClength])/(60*75),((TOCaddr[TOClength])/75)%60 );
  3614.                 set(TX_CDTime,MUIA_Text_Contents,buff);
  3615.                 set(TX_Track,MUIA_Text_Contents,"--");
  3616.                 set(TX_TitleTime,MUIA_Text_Contents,"--:--/--:--");
  3617.                 sprintf(buff,"%s - %s",TOCCDartist,TOCCDtitle);
  3618.                 set(TX_Artist,MUIA_Text_Contents,buff);
  3619.                 set(TX_Title,MUIA_Text_Contents,TOCCDtitle);
  3620.             }
  3621.         }
  3622.     }
  3623.     if(settimer)
  3624.     {
  3625.         if(skip)
  3626.             skip--;
  3627.         tioreq->tr_node.io_Command=TR_ADDREQUEST;
  3628.         tioreq->tr_time.tv_secs=microsleft/1000000;
  3629.         tioreq->tr_time.tv_micro=microsleft%1000000;
  3630.         SendIO((struct IORequest *)tioreq);
  3631.     }
  3632. }
  3633.  
  3634.  
  3635. /* THIS FUNCTION IS **NOT** SAFE!!!
  3636. ** I know it somehow works on my system, but I don't know how.
  3637. ** Anyway I leave it here, because I have nothing better. Perhaps I'll
  3638. ** find something better some day.        I DON'T KNOW HOW IT WORKS!!!
  3639. ** It takes a volume between 0 and 255.
  3640. */
  3641. void CDSetVolume(int volume)
  3642. {
  3643.     static SCSICMD6 modecommand;
  3644.     static struct volmodedata
  3645.     {
  3646.         UBYTE head[4];
  3647.         UBYTE page;     /* page code 0x0e */
  3648.         UBYTE plength;  /* page length */
  3649.         UBYTE b2;       /* bit2: Immed, bit 1: SOTC */
  3650.         UBYTE b3;       /* reserved */
  3651.         UBYTE b4;       /* reserved */
  3652.         UBYTE b5;       /* bit 7: APRVal, bit 3-0: format of LBAs / Sec. */
  3653.         UWORD bps;      /* logical blocks per second audio playback */
  3654.         UBYTE out0;     /* lower 4 bits: output port 0 channel selection */
  3655.         UBYTE vol0;     /* output port 0 volume */
  3656.         UBYTE out1;     /* lower 4 bits: output port 1 channel selection */
  3657.         UBYTE vol1;     /* output port 1 volume */
  3658.         UBYTE out2;     /* lower 4 bits: output port 2 channel selection */
  3659.         UBYTE vol2;     /* output port 2 volume */
  3660.         UBYTE out3;     /* lower 4 bits: output port 3 channel selection */
  3661.         UBYTE vol3;     /* output port 3 volume */
  3662.     } modedata;
  3663.     int i,err,j;
  3664.  
  3665.     if(!volumecontrol)
  3666.         return;
  3667.  
  3668.     for(i=0;i<4;i++)
  3669.         modedata.head[i]=0;
  3670.  
  3671.     modecommand.opcode=SCSI_CMD_MSE;
  3672.     modecommand.b1=0;            /* 0 */
  3673.     modecommand.b2=0x0e;         /* 0x0e */
  3674.     modecommand.b3=0;            /* 0 */
  3675.     modecommand.b4=64; /* MAX_DATA_LEN; */
  3676.     modecommand.control=0;
  3677.  
  3678.     if(err=DoScsiCmd((UBYTE *) scsidata, MAX_DATA_LEN, (UBYTE *) &modecommand, sizeof(modecommand), SCSIF_READ|SCSIF_AUTOSENSE))
  3679.         return;
  3680.  
  3681. /*    for(i=0;i<64;i++)
  3682.         printf("%02x",(int)scsidata[i]);
  3683.         printf("\n"); */
  3684.  
  3685.     for (j = (scsidata[0]+1), i = scsidata[3] + 4; i < j; i += scsidata[i+1] + 2)
  3686.         memcpy (&modedata.page, &scsidata[i], 16);
  3687.  
  3688.     modedata.page = 0x0e;
  3689.     modedata.plength = 0x0e;
  3690. /*    modedata.b2=4; */
  3691. /*    modedata.b5=0; */
  3692. /*    modedata.bps=NUM_OF_CDDAFRAMES; (0 en PlayCD)*/
  3693.     modedata.out0=1;
  3694.     modedata.out1=2;
  3695.     modedata.out2=0;
  3696.     modedata.out3=0;
  3697.  
  3698.     if(volume==-1)
  3699.     {
  3700.         volume=(modedata.vol0+modedata.vol1)/2;
  3701.         set(SL_Volume,MUIA_Slider_Level,volume);
  3702.     }
  3703.  
  3704.     if(volume<minvolume)
  3705.     {
  3706.         volume=minvolume;
  3707.     }
  3708.  
  3709.     modedata.vol0 = volume;
  3710.     modedata.vol1 = volume;
  3711.     modedata.vol2 = 0;
  3712.     modedata.vol3 = 0;
  3713.  
  3714.     modecommand.opcode      = SCSI_CMD_MSL;
  3715.     modecommand.b1          = 0x10;                /* 0 antes 0x10 */
  3716.     modecommand.b2          = 0;                   /* 0 */
  3717.     modecommand.b3          = 0;    /* 0x14 */
  3718.     modecommand.b4          = sizeof (modedata);   /* 0 */
  3719.     modecommand.control     = 0;
  3720.  
  3721.     if ((err = DoScsiCmd ((UBYTE *) &modedata, sizeof(modedata),
  3722.                           (UBYTE *) &modecommand, sizeof (modecommand),
  3723.                           (SCSIF_WRITE | SCSIF_AUTOSENSE))) != 0)
  3724.         return;
  3725.  
  3726. }
  3727.  
  3728. void CDPause(void)
  3729. {
  3730.     static SCSICMD10 command =
  3731.     {
  3732.         SCSI_CMD_PAUSERESUME,
  3733.         PAD,
  3734.         0,
  3735.         0,
  3736.         0,
  3737.         0,
  3738.         0,
  3739.         0,
  3740.         0,
  3741.         PAD,
  3742.     };
  3743.  
  3744.     command.b8 = 0x00; /* 0x01 for resuming */
  3745.  
  3746.     DoScsiCmd (NULL, NULL,
  3747.                (UBYTE *) & command, sizeof (command),
  3748.                (SCSIF_READ | SCSIF_AUTOSENSE));
  3749.     if(status==PLAYING)
  3750.         status=PAUSED;
  3751. }
  3752.  
  3753. void CDResume(void)
  3754. {
  3755.     static SCSICMD10 command =
  3756.     {
  3757.         SCSI_CMD_PAUSERESUME,
  3758.         PAD,
  3759.         0,
  3760.         0,
  3761.         0,
  3762.         0,
  3763.         0,
  3764.         0,
  3765.         0,
  3766.         PAD,
  3767.     };
  3768.  
  3769.     command.b8 = 0x01; /* 0x00 for pausing */
  3770.  
  3771.     DoScsiCmd (NULL, NULL,
  3772.                (UBYTE *) & command, sizeof (command),
  3773.                (SCSIF_READ | SCSIF_AUTOSENSE));
  3774. }
  3775.  
  3776. void CDPlay(int start, int length)
  3777. {
  3778.     static SCSICMD12 command =
  3779.     {
  3780.         SCSI_CMD_PLAYAUDIO12,
  3781.         PAD,
  3782.         0, 0, 0, 0,
  3783.         0, 0, 0, 0,
  3784.         PAD,
  3785.         PAD,
  3786.     };
  3787.     command.b2=(start&0xff000000)>>24;
  3788.     command.b3=(start&0x00ff0000)>>16;
  3789.     command.b4=(start&0x0000ff00)>>8;
  3790.     command.b5=(start&0x000000ff);
  3791.  
  3792.     command.b6=(length&0xff000000)>>24;
  3793.     command.b7=(length&0x00ff0000)>>16;
  3794.     command.b8=(length&0x0000ff00)>>8;
  3795.     command.b9=(length&0x000000ff);
  3796.  
  3797.     skip=3;
  3798.  
  3799.     userstop=FALSE;
  3800.     refresh=TRUE;
  3801.  
  3802.     DoScsiCmd((UBYTE *)scsidata,MAX_DATA_LEN,(UBYTE *)&command,sizeof(command),SCSIF_READ|SCSIF_AUTOSENSE);
  3803. }
  3804.  
  3805. void CDReadContents(void)
  3806. {
  3807.     char buff[1024],buff2[256];
  3808.     FILE *f;
  3809.     static SCSICMD10 command=
  3810.     {
  3811.         SCSI_CMD_READTOC,
  3812.         0,
  3813.         PAD,PAD,PAD,PAD,
  3814.         0,
  3815.         0x03,0x24,
  3816.         PAD
  3817.     };
  3818.     int err,TOCsize;
  3819.     UBYTE * TOCptr;
  3820.  
  3821.     validTOC=0;
  3822.  
  3823.     if(err=DoScsiCmd((UBYTE *)TOCbuf,MAX_TOC_LEN,(UBYTE *)&command,sizeof(command),SCSIF_READ|SCSIF_AUTOSENSE))
  3824.         return;
  3825.  
  3826.     TOCsize=(TOCbuf[0]<<8)|TOCbuf[1];
  3827.  
  3828.     TOCaddr[2]=TOCaddr[1]=TOCaddr[0]=0;
  3829.     TOClength=0;
  3830.  
  3831.     if(TOCsize>=2);
  3832.         TOCsize-=2;
  3833.  
  3834.     onevalid=FALSE;
  3835.     for(TOCptr=&TOCbuf[4];TOCptr<(&TOCbuf[4]+TOCsize) && TOClength<100;TOCptr+=8)
  3836.     {
  3837.         TOCaddr[TOClength]=(TOCptr[4]<<24)|(TOCptr[5]<<16)|(TOCptr[6]<<8)|(TOCptr[7]);
  3838.         onevalid|=!((TOCflags[TOClength]=(TOCptr[1]&0x04)>>2)&1);
  3839.         TOClength++;
  3840.     }
  3841.     TOClength--;
  3842.  
  3843.     sprintf(TOCCDID,"ID%02d%06X%06X",TOClength,TOCaddr[2],TOCaddr[TOClength]);
  3844.  
  3845.     set(BT_ProgramL,MUIA_Selected,FALSE);
  3846.     set(BT_Shuffle,MUIA_Selected,FALSE);
  3847.     set(BT_Repeat,MUIA_Selected,FALSE);
  3848.     set(CH_AutoPlay,MUIA_Selected,FALSE);
  3849.     set(CH_AutoProgram,MUIA_Selected,FALSE);
  3850.     set(CH_AutoShuffle,MUIA_Selected,FALSE);
  3851.     set(CH_AutoRepeat,MUIA_Selected,FALSE);
  3852.  
  3853.     useraction=-1;
  3854.  
  3855.     sprintf(buff,"%s%s",diskspath,TOCCDID);
  3856.     if(f=fopen(buff,"r"))
  3857.     {
  3858.         set(LV_TrackSelect,MUIA_List_Quiet,TRUE);
  3859.         set(LV_PList,MUIA_List_Quiet,TRUE);
  3860.         DoMethod(LV_TrackSelect,MUIM_List_Clear);
  3861.         DoMethod(LV_PList,MUIM_List_Clear);
  3862.         fgets(TOCCDartist,128,f);
  3863.         if(TOCCDartist[strlen(TOCCDartist)-1]=='\n')
  3864.             TOCCDartist[strlen(TOCCDartist)-1]='\0';
  3865.         fgets(TOCCDtitle,128,f);
  3866.         if(TOCCDtitle[strlen(TOCCDtitle)-1]=='\n')
  3867.             TOCCDtitle[strlen(TOCCDtitle)-1]='\0';
  3868.         for(err=0;err<TOClength;err++)
  3869.         {
  3870.             fgets(buff,128,f);
  3871.             if(buff[strlen(buff)-1]=='\n')
  3872.                 buff[strlen(buff)-1]='\0';
  3873.             sprintf(buff2,"%02d: %s",err+1,buff);
  3874.             DoMethod(LV_TrackSelect,MUIM_List_InsertSingle,buff2,MUIV_List_Insert_Bottom);
  3875.             DoMethod(LV_PList,MUIM_List_InsertSingle,buff2,MUIV_List_Insert_Bottom);
  3876.         }
  3877.  
  3878.         fgets(buff,128,f);
  3879.         if(*buff=='*')
  3880.         {
  3881.             err=buff[1]&15;
  3882.             if(err&8)
  3883.             {
  3884.                 set(CH_AutoRepeat,MUIA_Selected,TRUE);
  3885.                 if(status==STOPPED)
  3886.                     set(BT_Repeat,MUIA_Selected,TRUE);
  3887.             }
  3888.             if(err&4)
  3889.             {
  3890.                 set(CH_AutoShuffle,MUIA_Selected,TRUE);
  3891.                 if(status==STOPPED)
  3892.                     set(BT_Shuffle,MUIA_Selected,TRUE);
  3893.             }
  3894.             if(err&2)
  3895.             {
  3896.                 set(CH_AutoProgram,MUIA_Selected,TRUE);
  3897.                 if(status==STOPPED)
  3898.                     set(BT_ProgramL,MUIA_Selected,TRUE);
  3899.             }
  3900.             if(err&1)
  3901.             {
  3902.                 set(CH_AutoPlay,MUIA_Selected,TRUE);
  3903.             }
  3904.         }
  3905.  
  3906.         fclose(f);
  3907.         set(LV_TrackSelect,MUIA_List_Quiet,FALSE);
  3908.         set(LV_PList,MUIA_List_Quiet,FALSE);
  3909.     }
  3910.     else
  3911.     {
  3912.         set(LV_TrackSelect,MUIA_List_Quiet,TRUE);
  3913.         set(LV_PList,MUIA_List_Quiet,TRUE);
  3914.         DoMethod(LV_TrackSelect,MUIM_List_Clear);
  3915.         DoMethod(LV_PList,MUIM_List_Clear);
  3916.         strcpy(TOCCDartist,glstr(MSG_UnknownArtist));
  3917.         strcpy(TOCCDtitle,glstr(MSG_UnknownTitle));
  3918.         for(err=0;err<TOClength;err++)
  3919.         {
  3920.             if(TOCflags[err]&1)
  3921.                 sprintf(buff2,glstr(MSG_DataTrack),err+1);
  3922.             else
  3923.                 sprintf(buff2,glstr(MSG_TrackNo),err+1,err+1);
  3924.             DoMethod(LV_TrackSelect,MUIM_List_InsertSingle,buff2,MUIV_List_Insert_Bottom);
  3925.             if(!TOCflags[err])
  3926.                 DoMethod(LV_PList,MUIM_List_InsertSingle,buff2,MUIV_List_Insert_Bottom);
  3927.         }
  3928.         set(LV_TrackSelect,MUIA_List_Quiet,FALSE);
  3929.         set(LV_PList,MUIA_List_Quiet,FALSE);
  3930.     }
  3931.     sprintf(buff,"%s%s",diskspath,TOCCDID);
  3932.     buff[strlen(diskspath)]='P';
  3933.     buff[strlen(diskspath)+1]='R';
  3934.     if(f=fopen(buff,"r"))
  3935.     {
  3936.         int ppp,err;
  3937.  
  3938.         err=0;
  3939.  
  3940.         while((ppp=getc(f))!=EOF)
  3941.             pprog[err++]=(ppp>0 && ppp<=TOClength)?ppp:0;
  3942.  
  3943.         pprog[err]=0;
  3944.  
  3945.         fclose(f);
  3946.  
  3947.         set(LV_ProgramSelect,MUIA_List_Quiet,TRUE);        
  3948.         DoMethod(LV_ProgramSelect,MUIM_List_Clear);
  3949.         err=0;
  3950.         while(pprog[err])
  3951.         {
  3952.             char *strptr;
  3953.             
  3954.             DoMethod(LV_TrackSelect,MUIM_List_GetEntry,pprog[err]-1,&strptr);
  3955.             DoMethod(LV_ProgramSelect,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  3956.             err++;
  3957.         }
  3958.         set(LV_ProgramSelect,MUIA_List_Quiet,FALSE);
  3959.     }
  3960.     else
  3961.     {
  3962.         pprog[0]=0;
  3963.         DoMethod(LV_ProgramSelect,MUIM_List_Clear);
  3964.     }
  3965.             
  3966.     set(BT_List,MUIA_Disabled,FALSE);
  3967.     set(BT_ProgramR,MUIA_Disabled,FALSE);
  3968.     validTOC=1;
  3969.     
  3970.     if(*scriptoninsert)
  3971.     {
  3972.         LaunchARexxScript(scriptoninsert);
  3973.     }
  3974.     
  3975.     get(CH_AutoPlay,MUIA_Selected,&err);
  3976.     if(err && status==STOPPED)
  3977.     {
  3978.         delayedplay=3;
  3979.     }
  3980.  
  3981.     useraction=-1;
  3982. }
  3983.  
  3984. void DoShuffle(void)
  3985. {
  3986.     int i,j,mx=0,k;
  3987.  
  3988.     programmed[0]=0;
  3989.  
  3990.     if(!onevalid)
  3991.         return;
  3992.  
  3993.     srand(time(NULL));
  3994.  
  3995.     for(i=0;i<TOClength;i++)
  3996.         mx+=!TOCflags[i];
  3997.  
  3998.     for(i=0;i<mx;i++)
  3999.     {
  4000.         programmed[i]=rand()%TOClength;
  4001.         k=TRUE;
  4002.         while(k)
  4003.         {
  4004.             k=TOCflags[programmed[i]];
  4005.  
  4006.             for(j=0;j<i;j++)
  4007.                 k|=(programmed[j]==programmed[i]);
  4008.  
  4009.             if(k)
  4010.             {
  4011.                 programmed[i]++;
  4012.                 programmed[i]%=TOClength;
  4013.             }
  4014.         }
  4015.     }
  4016.     for(i=0;i<mx;i++)
  4017.         programmed[i]++;
  4018.     programmed[mx]=0;
  4019. }
  4020.  
  4021. void DoProgram(void)
  4022. {
  4023.     int i;
  4024.     i=0;
  4025.     while(programmed[i]=pprog[i])
  4026.         i++;
  4027. }
  4028.  
  4029. void FillList(void)
  4030. {
  4031.     int i;
  4032.     UBYTE *strptr;
  4033.  
  4034.     set(ST_Artist,MUIA_String_Contents,TOCCDartist);
  4035.     set(ST_CDTitle,MUIA_String_Contents,TOCCDtitle);
  4036.     set(LV_TitleList,MUIA_List_Quiet,TRUE);
  4037.     DoMethod(LV_TitleList,MUIM_List_Clear);
  4038.     for(i=0;i<TOClength;i++)
  4039.     {
  4040.         DoMethod(LV_TrackSelect,MUIM_List_GetEntry,i,&strptr);
  4041.         DoMethod(LV_TitleList,MUIM_List_InsertSingle,strptr,MUIV_List_Insert_Bottom);
  4042.     }
  4043.     set(LV_TitleList,MUIA_List_Active,0);
  4044.     set(LV_TitleList,MUIA_List_Quiet,FALSE);
  4045.     set(WI_List,MUIA_Window_ActiveObject,ST_Artist);
  4046.     set(WI_List,MUIA_Window_Open,TRUE);
  4047. }
  4048.  
  4049.